@ultimat3/admin 22.14.0 → 23.0.0

package/src/repo-entity.ts

@@ -0,0 +1,204 @@
+// The ONE adapter from an entity's typed handle — `database()`'s `db.<entity>` — to `AdminRepo`.
+// Verbs, the keyset bound and filters are translated here and nowhere else; tenancy, soft delete,
+// sealing and invariants stay the handle's, so this file adds no predicate of its own.
+
+import { isUltimateError } from '@ultimat3/core';
+import { getEntity, invariantViolated } from '@ultimat3/entity';
+import { adminColumnsOf } from './entity-columns';
+import type {
+  AdminDb,
+  AdminEntity,
+  AdminFilter,
+  AdminListQuery,
+  AdminRepo,
+  AdminRow,
+  AdminTable,
+  AdminTableRead,
+} from './registry';
+
+type TableOperator = Parameters<AdminTableRead['andWhere']>[1];
+
+/**
+ * `contains` is the admin's word for it; `like` with both wildcards is what a driver runs. A Map,
+ * so an operator that is not one of the seven answers `undefined` rather than a prototype member.
+ */
+const OPERATOR_OF: ReadonlyMap<AdminFilter['op'], TableOperator> = new Map([
+  ['eq', 'eq'],
+  ['neq', 'neq'],
+  ['contains', 'like'],
+  ['gt', 'gt'],
+  ['gte', 'gte'],
+  ['lt', 'lt'],
+  ['lte', 'lte'],
+  ['in', 'in'],
+  ['is-null', 'is-null'],
+]);
+
+/** `%` and `_` are wildcards to `LIKE`; a `contains` matches the text an operator typed. */
+const literal = (text: string): string => text.replace(/[\\%_]/g, (wild) => `\\${wild}`);
+
+/**
+ * A comparison value, in the shape the column holds. An instant travels as ISO text — in a URL, in
+ * a cursor — and the handle is given the `Date`: Postgres would cast the text, the memory driver
+ * compares a `Date` to a string by its characters, and a keyset over `createdAt` (the admin's
+ * default sort) then answers page one for every page.
+ */
+type Typed = (field: string, value: unknown) => unknown;
+
+const typedBy = (entity: AdminEntity): Typed => {
+  const instants = new Set(
+    adminColumnsOf(entity)
+      .filter((column) => column.kind === 'timestamptz')
+      .map((column) => column.name),
+  );
+  return (field, value) => {
+    if (typeof value !== 'string' || !instants.has(field)) return value;
+    const at = new Date(value);
+    return Number.isNaN(at.getTime()) ? value : at;
+  };
+};
+
+const predicate =
+  (typed: Typed) =>
+  (read: AdminTableRead, filter: AdminFilter): AdminTableRead => {
+    if (filter.op === 'contains') {
+      return read.andWhere(filter.field, 'like', `%${literal(String(filter.value))}%`);
+    }
+    // One admin operator, two of the handle's: `false` asks for the rows that HAVE a value.
+    if (filter.op === 'is-null') {
+      return read.andWhere(filter.field, filter.value === false ? 'is-not-null' : 'is-null');
+    }
+    return read.andWhere(
+      filter.field,
+      OPERATOR_OF.get(filter.op) ?? 'eq',
+      typed(filter.field, filter.value),
+    );
+  };
+
+const filtered = (
+  read: AdminTableRead,
+  where: readonly AdminFilter[],
+  typed: Typed,
+): AdminTableRead => where.reduce(predicate(typed), read);
+
+/**
+ * `after`+asc and `before`+desc walk forward; the other two walk back. Written as one XOR rather
+ * than a four-branch table, because the four branches are the same fact said twice.
+ *
+ * `gte`/`lte`, not `gt`/`lt`: rows sharing the boundary's sort value are still on the far side of
+ * it, and `dropThroughTie` below is what removes the ones already served.
+ */
+const sought = (read: AdminTableRead, query: AdminListQuery, typed: Typed): AdminTableRead => {
+  const bound = query.after ?? query.before;
+  if (bound === undefined) return read;
+  const forward = (query.after !== undefined) !== (query.sort.direction === 'desc');
+  // The bound is the STRING the cursor carried (`pagination.ts` writes a Date as ISO).
+  return read.andWhere(bound.field, forward ? 'gte' : 'lte', typed(bound.field, bound.value));
+};
+
+/**
+ * Drop everything up to and including the cursor row. A typed chain cannot express the row-value
+ * comparison `(sort, id) > (value, id)` a keyset needs, and the alternative — a strict `gt` on the
+ * sort column alone — silently skips every row that ties with the boundary.
+ */
+const dropThroughTie = (
+  rows: readonly AdminRow[],
+  query: AdminListQuery,
+  idField: string,
+): readonly AdminRow[] => {
+  const bound = query.after ?? query.before;
+  if (bound === undefined) return rows;
+  const at = rows.findIndex((row) => String(row[idField]) === bound.id);
+  return at === -1 ? rows : rows.slice(at + 1);
+};
+
+/**
+ * One entity + its table → one `AdminRepo`.
+ *
+ * A row is never spread and never re-parsed here. The handle parses an insert against the entity
+ * and asserts every invariant over the stored row merged under a patch, so a second parse would be
+ * a second opinion — and a row's sealed properties are non-enumerable, so a spread would drop the
+ * very values a whole-row write then needs.
+ */
+export function adminRepoFor(entity: AdminEntity, table: AdminTable): AdminRepo<AdminRow> {
+  const idField = entity.$primaryKey[0] ?? 'id';
+  const idColumn = Object.hasOwn(entity.$columns, idField) ? entity.$columns[idField] : undefined;
+  const typed = typedBy(entity);
+  /**
+   * `AdminRepo` carries `id: string` — a URL param, untyped by nature. The primary key column's
+   * OWN `$parse` is what earns the crossing: `/posts/nope` is judged here, at the door, instead
+   * of reaching the driver as a comparison Postgres answers with a cast error.
+   */
+  const idOf = (id: string): string => {
+    const parsed = idColumn?.$parse === undefined ? id : idColumn.$parse(id);
+    if (typeof parsed !== 'string') {
+      throw invariantViolated(entity.$name, idField, `expected a string id, got ${typeof parsed}`);
+    }
+    return parsed;
+  };
+  /**
+   * The same crossing for a READ, where an id that is not one is simply a row that does not exist:
+   * `/posts/nope` is the admin's 404, not `X_INVARIANT_VIOLATED` — the operator mistyped a URL and
+   * violated nothing. A write keeps the throw: it is reached only after a read found the row.
+   */
+  const readableId = (id: string): string | undefined => {
+    try {
+      return idOf(id);
+    } catch (error) {
+      if (isUltimateError(error) && error.code === 'X_INVARIANT_VIOLATED') return undefined;
+      throw error;
+    }
+  };
+
+  return {
+    async list(query: AdminListQuery): Promise<readonly AdminRow[]> {
+      const rows = await sought(filtered(table, query.where ?? [], typed), query, typed)
+        .orderBy(query.sort.field, query.sort.direction)
+        // The tie-break, always: a page boundary on a partial order repeats or drops a row.
+        .orderBy(idField, query.sort.direction)
+        // One over the requested page so the tie-drop cannot hand back a short page.
+        .limit(query.limit + 1)
+        .all();
+      return dropThroughTie(rows, query, idField).slice(0, query.limit);
+    },
+    // `async`, so a refused id arrives as a rejection: these return promises, and a caller that
+    // chains `.catch()` instead of `await`ing would never see a synchronous throw.
+    find: async (id) => {
+      const key = readableId(id);
+      return key === undefined ? null : table.where({ [idField]: key }).one();
+    },
+    create: async (input) => table.insert(input),
+    update: async (id, patch) => table.update(idOf(id), patch),
+    destroy: async (id) => table.delete(idOf(id)),
+    count: async (where) => filtered(table, where ?? [], typed).count(),
+  };
+}
+
+/**
+ * The handle's tables, by the ENTITY they serve. `database({ posts })` keys a table by the app's
+ * own spelling, which need not be the entity's `$name` — so the name is read off the table's own
+ * plan rather than off the key it happens to sit under.
+ */
+export function adminTablesOf(db: AdminDb): ReadonlyMap<string, AdminTable> {
+  return new Map(Object.values(db).map((table) => [table.plan().entity, table]));
+}
+
+/**
+ * Every entity the handle serves that the admin can address — what an app passes as `entities`
+ * when its admin is "all of my tables": `defineAdmin({ entities: adminEntitiesOf(db), db })`. The
+ * handle's set is the one `x g entity` adds to, so a new entity is a new admin resource with no
+ * second registration.
+ *
+ * An entity keyed on more than one column is left out: a route id and an `AdminRepo` id carry one
+ * string. Name it in `entities` yourself and `defineAdmin` refuses it out loud
+ * (`X_ADMIN_FIELD_UNSUPPORTED`) — this helper is "everything that can be a screen", not a claim
+ * that everything is. Handle order, which is the order the app declared.
+ */
+export function adminEntitiesOf(db: AdminDb): readonly AdminEntity[] {
+  const found: AdminEntity[] = [];
+  for (const name of adminTablesOf(db).keys()) {
+    const declared = getEntity(name)?.core;
+    if (declared !== undefined && declared.$primaryKey.length === 1) found.push(declared);
+  }
+  return found;
+}

package/src/resource-fields.ts

@@ -0,0 +1,116 @@
+// One column → one admin field. Everything a list cell, a detail row, a form input, a filter and
+// an MCP tool schema need is decided here, once, from the column's facts and the app's override —
+// and a sealed column is derived by a function of its own, whose every read flag is false.
+
+import type { AdminColumnFacts } from './entity-columns';
+import {
+  type AdminField,
+  type AdminFieldType,
+  type AdminWidget,
+  fieldTypeFromColumn,
+  filterable,
+  filterKindFor,
+  listable,
+  searchable,
+  sortable,
+  widgetFor,
+} from './fields';
+import type { AdminEntity } from './registry';
+
+export interface AdminFieldOverride {
+  readonly type?: AdminFieldType;
+  readonly widget?: AdminWidget;
+  readonly labelKey?: string;
+  /** Out of every surface: list, detail, form, MCP schema. */
+  readonly hidden?: boolean;
+  readonly inList?: boolean;
+  readonly readOnly?: boolean;
+  readonly required?: boolean;
+  readonly sensitive?: boolean;
+  readonly filterable?: boolean;
+  readonly sortable?: boolean;
+  readonly searchable?: boolean;
+  readonly currency?: string;
+  readonly values?: readonly string[];
+  /** The resource a foreign key points at, when the entity's own `references()` is not it. */
+  readonly relation?: { readonly entity: string };
+  /** i18n key of the hint under the form control, rendered through `t()`. */
+  readonly hintKey?: string;
+  /** The field is a form input on one side only: set at `create`, or editable from `update`. */
+  readonly on?: 'create' | 'update';
+}
+
+export function deriveField(
+  entity: AdminEntity,
+  column: AdminColumnFacts,
+  override: AdminFieldOverride | undefined,
+): AdminField {
+  const name = column.name;
+  const type = override?.type ?? fieldTypeFromColumn(entity.$name, name, column);
+  const widget = override?.widget ?? widgetFor(type);
+  const generated = column.generated || column.primaryKey;
+  // `sensitive` is the ADMIN's word for "keep this out of the list, the form and every audit
+  // diff" (an email, a phone number) and it has no entity source, so it is declared here or it is
+  // absent. A column the entity itself seals (`.sealed()`) never reaches this function at all —
+  // `secretField` below derives it. A currency belongs to the value rather than the column.
+  const sensitive = override?.sensitive ?? false;
+  const currency = override?.currency;
+  const values = override?.values ?? column.values;
+  const relation =
+    override?.relation ??
+    (column.references === undefined ? undefined : { entity: column.references.entity });
+  // The handle scopes every read and write by this column, so the acting actor's tenant is the
+  // only value it can hold: it is not an input, not a list column, and not a filter.
+  const tenant = entity.$tenantColumn === name;
+  const filterKind = tenant ? undefined : filterKindFor(type, column);
+
+  return {
+    entity: entity.$name,
+    name,
+    type,
+    widget,
+    labelKey: override?.labelKey ?? `admin.${entity.$name}.field.${name}`,
+    required: override?.required ?? (!column.nullable && !generated && !tenant),
+    readOnly: override?.readOnly ?? (generated || tenant),
+    sensitive,
+    inList: override?.inList ?? (listable(type) && !sensitive && !tenant),
+    filterable: filterKind !== undefined && (override?.filterable ?? filterable(type, column)),
+    ...(filterKind === undefined ? {} : { filterKind }),
+    sortable: override?.sortable ?? sortable(type, column),
+    // Generated columns are excluded from search: an id is found by exact lookup, and a
+    // `contains` over a uuid column is a scan that returns nothing useful.
+    searchable: override?.searchable ?? (searchable(type, column) && !sensitive && !generated),
+    ...(values === undefined ? {} : { values }),
+    ...(currency === undefined ? {} : { currency }),
+    ...(relation === undefined ? {} : { relation }),
+    ...(override?.hintKey === undefined ? {} : { hintKey: override.hintKey }),
+    ...(override?.on === undefined ? {} : { on: override.on }),
+  };
+}
+
+/**
+ * A sealed column as the form sees it: a password-style input, required only on create, and
+ * nothing else. Every read flag is false by construction, not by an override an app could flip.
+ */
+export function secretField(
+  entity: AdminEntity,
+  column: AdminColumnFacts,
+  override: AdminFieldOverride | undefined,
+): AdminField {
+  return {
+    entity: entity.$name,
+    name: column.name,
+    type: 'secret',
+    widget: 'secret-input',
+    labelKey: override?.labelKey ?? `admin.${entity.$name}.field.${column.name}`,
+    required: !column.nullable,
+    readOnly: false,
+    sensitive: true,
+    inList: false,
+    filterable: false,
+    sortable: false,
+    searchable: false,
+    ...(override?.hintKey === undefined ? {} : { hintKey: override.hintKey }),
+    ...(override?.on === undefined ? {} : { on: override.on }),
+  };
+}

package/src/resource-layout.ts

@@ -0,0 +1,89 @@
+// How a resource's fields are ARRANGED: the detail page's sections and the form's groups. One
+// normaliser for both, and one rule that makes it safe to declare either — a field named in no
+// group falls into a default one, so adding a column to the entity never hides it from a screen.
+
+import { AdminFieldUnsupportedError } from './errors';
+import type { AdminField } from './fields';
+
+/** One declared group: a titled run of fields, in the order they are named. */
+export interface AdminSectionOptions {
+  /** i18n key of the heading. */
+  readonly titleKey: string;
+  readonly fields: readonly string[];
+}
+
+/** The form's spelling of the same thing. One shape, so a detail and its form can share a list. */
+export type AdminFormGroupOptions = AdminSectionOptions;
+
+export interface AdminSection {
+  /** `null` only for the single group of a resource that declared none: it has no heading. */
+  readonly titleKey: string | null;
+  readonly fields: readonly AdminField[];
+  /** The group the undeclared fields fell into. Drawn last. */
+  readonly default: boolean;
+}
+
+/** The heading of the default group, when declared groups sit above it. */
+export const DEFAULT_SECTION_KEY = 'admin.section.other';
+
+interface Layout {
+  readonly entity: string;
+  /** `sections` or `formGroups` — what a refusal names. */
+  readonly option: 'sections' | 'formGroups';
+  /** The fields this layout may arrange, in derived order. */
+  readonly fields: readonly AdminField[];
+  /** Why a named field that is a column is still not one of `fields`. */
+  readonly excluded: string;
+}
+
+/**
+ * Declared groups in declaration order, then the default group holding every field nobody named —
+ * in derived order — when there is one. A name that is not a field of this layout, or that two
+ * groups both claim, is refused where it is written.
+ */
+export function layoutOf(
+  layout: Layout,
+  declared: readonly AdminSectionOptions[] | undefined,
+): readonly AdminSection[] {
+  if (declared === undefined || declared.length === 0) {
+    return [{ titleKey: null, fields: layout.fields, default: true }];
+  }
+  const claimed = new Map<string, string>();
+  const groups = declared.map((group): AdminSection => {
+    const fields = group.fields.map((name) => {
+      const field = layout.fields.find((known) => known.name === name);
+      const refuse = (cause: string, fix: string): never => {
+        throw new AdminFieldUnsupportedError({ entity: layout.entity, field: name, cause, fix });
+      };
+      if (field === undefined) {
+        return refuse(
+          `named in ${layout.option} ("${group.titleKey}") and ${layout.excluded}`,
+          `remove "${name}" from resources.${layout.entity}.${layout.option} — it may name: ${layout.fields.map((known) => known.name).join(', ')}`,
+        );
+      }
+      const owner = claimed.get(name);
+      if (owner !== undefined) {
+        return refuse(
+          `named in two ${layout.option} groups ("${owner}" and "${group.titleKey}")`,
+          `keep "${name}" in one group of resources.${layout.entity}.${layout.option}`,
+        );
+      }
+      claimed.set(name, group.titleKey);
+      return field;
+    });
+    return { titleKey: group.titleKey, fields, default: false };
+  });
+  const rest = layout.fields.filter((field) => !claimed.has(field.name));
+  return rest.length === 0
+    ? groups
+    : [...groups, { titleKey: DEFAULT_SECTION_KEY, fields: rest, default: true }];
+}
+
+/** The fields of one group a form in `mode` draws: a field declared for the other side is left out. */
+export function fieldsFor(
+  fields: readonly AdminField[],
+  mode: 'create' | 'edit',
+): readonly AdminField[] {
+  const side = mode === 'create' ? 'create' : 'update';
+  return fields.filter((field) => field.on === undefined || field.on === side);
+}

package/src/resource-list.ts

@@ -0,0 +1,185 @@
+// The list half of a resource declaration: scopes, the row scope and computed columns — each
+// normalised once and validated where it is written, so a list screen, the search, the lookup and
+// the MCP tool all read the same three values and none of them re-reads the options.
+
+import type { JSX } from 'solid-js';
+import type { AdminActor } from './authz';
+import { AdminFieldUnsupportedError, AdminFilterInvalidError } from './errors';
+import { declaredFilters } from './list-filters';
+import type { AdminEntity, AdminFilter, AdminRepo, AdminRow } from './registry';
+import type { WidgetContext } from './widget-value';
+
+/**
+ * The path segment a resource's lookup is mounted under: `/admin/<resource>/lookup`. A literal
+ * segment outranks `:id`, exactly as `new` does, so no row can be shadowed by it.
+ */
+export const LOOKUP_SEGMENT = 'lookup';
+
+/** Predicates, or predicates of the acting actor (`mine`, `my team's`). */
+export type AdminScopeWhere =
+  | readonly AdminFilter[]
+  | ((actor: AdminActor) => readonly AdminFilter[]);
+
+export interface AdminScopeOptions {
+  readonly where: AdminScopeWhere;
+  /** The scope a bare list URL applies. At most one; with none, the bare list is unscoped. */
+  readonly default?: boolean;
+  /** Show the row count on the tab. Opt-in: a count is a query, on a big table a slow one. */
+  readonly count?: boolean;
+  /** Omitted: `admin.<entity>.scope.<name>`. */
+  readonly labelKey?: string;
+}
+
+/** A declared scope, normalised. `where` is checked on every call — it may depend on the actor. */
+export interface AdminScope {
+  readonly name: string;
+  readonly labelKey: string;
+  readonly default: boolean;
+  readonly count: boolean;
+  where(actor: AdminActor): readonly AdminFilter[];
+}
+
+/**
+ * Which rows of a resource one actor may see at all. One declaration, applied by every read the
+ * admin issues for the resource — list, search, detail, lookup, label, the MCP tools — so a second
+ * audience is a function of the actor and never a second copy of the resource.
+ */
+export type AdminRowScope = (actor: AdminActor) => readonly AdminFilter[];
+
+/** The closed set. An app needing a seventh passes a component for that column. */
+export const ADMIN_RENDERERS = [
+  'badge',
+  'relative-time',
+  'money',
+  'truncate',
+  'link',
+  'json',
+] as const;
+
+export type AdminRenderer = (typeof ADMIN_RENDERERS)[number];
+
+export interface AdminColumnRenderProps<Row extends AdminRow = AdminRow> {
+  readonly value: unknown;
+  readonly row: Row;
+  readonly ctx: WidgetContext;
+}
+
+export type AdminColumnComponent<Row extends AdminRow = AdminRow> = (
+  props: AdminColumnRenderProps<Row>,
+) => JSX.Element;
+
+export interface AdminComputedColumnOptions<Row extends AdminRow = AdminRow> {
+  /**
+   * The cell's value, from the row. The row it is handed carries no sealed column: a computed
+   * column is rendered, and a sealed value is never rendered.
+   */
+  readonly value: (row: Row) => unknown;
+  readonly render: AdminRenderer | AdminColumnComponent<Row>;
+  /** Omitted: `admin.<entity>.column.<name>`. */
+  readonly labelKey?: string;
+}
+
+/**
+ * A declared column, normalised — and typed over `AdminRow`, never the app's own `Row`: a resource
+ * that carried `(row: Row) => …` would be invariant in `Row`, and every function taking "any
+ * resource" would stop accepting one. The narrowing back happens once, in `computedColumnsOf`.
+ */
+export interface AdminComputedColumn extends AdminComputedColumnOptions<AdminRow> {
+  readonly name: string;
+  readonly labelKey: string;
+}
+
+interface Declared {
+  readonly name: string;
+  readonly entity: AdminEntity;
+}
+
+/** The declared scopes, in declaration order — which is the order the tabs are drawn in. */
+export function scopesOf(
+  resource: Declared,
+  scopes: Readonly<Record<string, AdminScopeOptions>> | undefined,
+  repo: AdminRepo<AdminRow> | undefined,
+): readonly AdminScope[] {
+  const entries = Object.entries(scopes ?? {});
+  const names = entries.map(([name]) => name);
+  const refuse = (asked: string, cause: string): never => {
+    throw new AdminFilterInvalidError({ entity: resource.name, asked, cause, known: names });
+  };
+  const defaults = entries.filter(([, scope]) => scope.default === true).map(([name]) => name);
+  if (defaults.length > 1) {
+    refuse(
+      `scopes: ${defaults.join(', ')}`,
+      'marks more than one scope `default: true`; a bare list URL applies exactly one',
+    );
+  }
+  return entries.map(([name, scope]) => {
+    const declaredAs = `scopes.${name}.where`;
+    // A tab's count is `AdminRepo.count`, which a hand-written repo may leave out: refused where
+    // the scope is declared, rather than drawn as a tab whose number silently never appears.
+    if (scope.count === true && repo !== undefined && repo.count === undefined) {
+      refuse(
+        `scopes.${name}.count`,
+        'asks for a count, and the repo this resource reads through has no count()',
+      );
+    }
+    const where = scope.where;
+    if (typeof where !== 'function') declaredFilters(resource, where, declaredAs);
+    return {
+      name,
+      labelKey: scope.labelKey ?? `admin.${resource.name}.scope.${name}`,
+      default: scope.default === true,
+      count: scope.count === true,
+      where: (actor) =>
+        typeof where === 'function' ? declaredFilters(resource, where(actor), declaredAs) : where,
+    };
+  });
+}
+
+/** `rows`, checked on every call. Absent stays absent: an unscoped resource asks no predicate. */
+export function rowScopeOf(
+  resource: Declared,
+  rows: AdminRowScope | undefined,
+): AdminRowScope | undefined {
+  if (rows === undefined) return undefined;
+  return (actor) => declaredFilters(resource, rows(actor), 'rows');
+}
+
+const isRenderer = (value: unknown): value is AdminRenderer =>
+  (ADMIN_RENDERERS as readonly unknown[]).includes(value);
+
+/** Declaration order, after the entity's own list fields. */
+export function computedColumnsOf<Row extends AdminRow>(
+  resource: Declared,
+  columns: Readonly<Record<string, AdminComputedColumnOptions<Row>>> | undefined,
+): readonly AdminComputedColumn[] {
+  return Object.entries(columns ?? {}).map(([name, column]) => {
+    if (Object.hasOwn(resource.entity.$columns, name)) {
+      throw new AdminFieldUnsupportedError({
+        entity: resource.name,
+        field: name,
+        cause: 'is declared in `columns:` and is also a column of the entity',
+        fix: `rename the computed column in resources.${resource.name}.columns — e.g. ${name}Label — or drop it and let the admin render the column itself`,
+      });
+    }
+    if (typeof column.render !== 'function' && !isRenderer(column.render)) {
+      throw new AdminFieldUnsupportedError({
+        entity: resource.name,
+        field: name,
+        cause: `names a renderer the admin does not have (it has: ${ADMIN_RENDERERS.join(', ')})`,
+        fix: `set resources.${resource.name}.columns.${name}.render to one of those, or pass a component: render: (props) => <YourCell {...props} />`,
+      });
+    }
+    const render = column.render;
+    return {
+      name,
+      labelKey: column.labelKey ?? `admin.${resource.name}.column.${name}`,
+      // The rows a resource's list hands these ARE its `Row`s: the declaration's own type is
+      // restored here, at the one place the two meet.
+      value: (row) => column.value(row as Row),
+      render:
+        typeof render === 'function'
+          ? (props) => render({ ...props, row: props.row as Row })
+          : render,
+    };
+  });
+}