@nest-my-admin/core 0.3.1 → 0.4.1

package/dist/contract.d.ts

@@ -38,7 +38,7 @@ export interface FieldSchema {
     help?: string;
     placeholder?: string;
     /** The widget chosen in the field config; the UI infers one from the type when absent. */
-    widget?: 'text' | 'textarea' | 'number' | 'money' | 'switch' | 'checkbox' | 'select' | 'radio' | 'date' | 'datetime' | 'json' | 'color' | 'badge' | 'slug' | 'password' | 'email' | 'url' | 'file' | 'image' | 'richtext';
+    widget?: 'text' | 'textarea' | 'number' | 'money' | 'switch' | 'checkbox' | 'select' | 'radio' | 'date' | 'datetime' | 'json' | 'color' | 'badge' | 'slug' | 'password' | 'email' | 'url' | 'file' | 'image' | 'richtext' | 'stepper';
     /** Display labels of enum values (values sent stay the raw ones). */
     enumLabels?: Record<string, string>;
     /** Badge colour per value. */
@@ -47,8 +47,22 @@ export interface FieldSchema {
     showIf?: Record<string, string | number | boolean | null | Array<string | number | boolean | null>>;
     /** The slug widget fills itself from this field until edited. */
     slugFrom?: string;
-    /** Currency code for the money widget (display only). */
-    currency?: string;
+    /**
+     * `stepper` widget: the steps in order, the values that are not steps (shown as a badge), and whether records carry
+     * `_steps` (when each step was reached, from the history child).
+     */
+    steps?: {
+        values: string[];
+        exclude: string[];
+        history: boolean;
+    };
+    /** A soft warning shown under the input while it is empty; the save still goes through. */
+    warnIf?: {
+        empty: true;
+        message: string;
+    };
+    /** The money widget's unit in the request's language, and where it goes (display only). */
+    currency?: CurrencyDisplay;
     /** Set for `file` and `image` widgets: what may be uploaded to the field. */
     file?: {
         accept: string[];
@@ -125,12 +139,30 @@ export interface FormLayoutInline {
     max: number;
     /** The child's field that points at the parent (set by the server). */
     link: string;
+    /** Shown, never edited in this form (writes are refused). */
+    readonly?: true;
+    /** The child's computed columns shown in the table (`_computed` on each row), cut to what this user may see. */
+    computed?: string[];
+    /** A marker on the first card by `order` («Main picture»). */
+    markFirst?: string;
+}
+/** Label and value rows in a card (an order's totals): a field of the record, or one of its computed columns (`_computed`). */
+export interface FormLayoutSummary {
+    title?: string;
+    summary: Array<{
+        label: string;
+        value: {
+            field: string;
+        } | {
+            computed: string;
+        };
+    }>;
 }
 export interface FormLayoutTab {
     tab: string;
-    sections: Array<FormLayoutSection | FormLayoutInline>;
+    sections: Array<FormLayoutSection | FormLayoutInline | FormLayoutSummary>;
 }
-export type FormLayoutNode = FormLayoutSection | FormLayoutTab | FormLayoutInline;
+export type FormLayoutNode = FormLayoutSection | FormLayoutTab | FormLayoutInline | FormLayoutSummary;
 /** One inline of a record (`_inlines[child]` on `GET /resources/:parent/:id`). */
 export interface InlineRows {
     /** The children of this record, as the child's own endpoints answer them (`_id`, `_perm`, `_readonly`, `_files`…), by `order` then key. */
@@ -246,6 +278,8 @@ export interface ActionSchema {
     /** Ask before running: `true` for the default question, or the question itself. */
     confirm?: string | true;
     variant: 'default' | 'destructive';
+    /** The record's next step: a filled button, last in the record's header (record actions without input, one per resource). */
+    primary?: true;
     icon?: string;
     /** The form to fill in before running; its values are sent as `input`. */
     input?: DtoFormSchema;
@@ -336,7 +370,47 @@ export interface MetaResponse {
     /** Languages people can switch between. */
     locales: string[];
     groups: MetaGroup[];
+    /** This user may see at least one dashboard widget: the dashboard replaces the home page. */
+    dashboard?: boolean;
+    /** The host's curated menu (`menu` option), cut to what this user reaches; absent without one (groups are the menu). */
+    menu?: MetaMenu;
 }
+/** One entry of a menu section. */
+export type MetaMenuItem = {
+    kind: 'resource';
+    resource: string;
+    label: string;
+    icon?: string;
+    creatable: boolean;
+    searchable: boolean;
+    /** A count is served for it by `GET /api/menu/badges` (key `<section>.<resource>`). */
+    badge?: true;
+} | {
+    kind: 'page';
+    page: string;
+    label: string;
+    icon?: string;
+} | {
+    kind: 'link';
+    href: string;
+    label: string;
+};
+export interface MetaMenuSection {
+    key: string;
+    label: string;
+    icon?: string;
+    items: MetaMenuItem[];
+}
+export interface MetaMenu {
+    sections: MetaMenuSection[];
+    /** Everything visible that no section places (key `advanced`), collapsed by default. May be empty. */
+    advanced: MetaMenuSection;
+}
+/** `GET /api/menu/badges`: counts by `<section>.<resource>`, scoped to the viewer; a badge the viewer may not count is absent. */
+export type MenuBadges = Record<string, {
+    count: number;
+    estimate: boolean;
+}>;
 export type SortDirection = 'asc' | 'desc';
 export type FilterOperator = 'eq' | 'ne' | 'in' | 'nin' | 'lt' | 'lte' | 'gt' | 'gte' | 'between' | 'contains' | 'startsWith' | 'isNull';
 /** A filterable field and the operators its column type supports (spec §11). */
@@ -375,10 +449,16 @@ export interface ResourceSchema {
             badge?: string;
             meta: string[];
         };
+        /** Tabs over the list (`list.tabs`) this viewer may use: a tab writes `filter` to the URL, plus `tab=<key>` when `where`. */
+        tabs?: ListTabSchema[];
+        /** Computed columns (`list.computed`) this viewer may see, by key; their values are each record's `_computed`. */
+        computed?: Record<string, ComputedColumnSchema>;
     };
     /** False for the root of a single-table inheritance, or when the user may not create. */
     creatable: boolean;
     /** What the signed-in user may do (spec §6.1); records may narrow update/delete in `_perm`. */
+    /** `@AdminResource({ readonly: true })`: nothing is created, changed or deleted through the admin (actions still run). */
+    readonly?: boolean;
     permissions?: {
         create: boolean;
         update: boolean;
@@ -411,8 +491,22 @@ export interface ResourceSchema {
         requiredOnCreate: string[];
         /** Shown on the update form but not writable (`readonly: true`); records add their own in `_readonly`. */
         readonly: string[];
-        /** Sections, inlines and tabs (`form.layout`); absent = one section in form order. */
+        /** Sections, inlines and tabs (`form.layout`, or its main column); absent = one section in form order. */
         layout?: FormLayoutNode[];
+        /** Read-only cards beside the main column (`form.layout.aside`), cut to what this user may see. */
+        aside?: AsideCardSchema[];
+        /** `view`: an existing record opens as text until «Edit». */
+        mode?: 'view';
+        /** The record's header: badge fields, and a subtitle of field values and computed columns (`_computed`). */
+        header?: {
+            badges?: string[];
+            subtitle?: Array<{
+                field: string;
+            } | {
+                computed: string;
+            }>;
+            stepper?: string;
+        };
         constraints: {
             create: Record<string, FieldConstraints>;
             update: Record<string, FieldConstraints>;
@@ -433,6 +527,8 @@ export interface ResourceSchema {
  * resources with such fields add `_files`: field name → `AdminFileRef` (`AdminFileRef[]` with `file.many`) for every
  * field that holds a file. `GET /resources/:resource/:id` of a resource with inlines adds `_inlines`: child resource
  * name → `InlineRows`, for each inline the user may see; so do the answers of its POST and PATCH, read after the save.
+ * List pages of a resource with `list.computed` add `_computed`: column key → `ComputedValue`, for the computed columns
+ * the user may see and the page shows.
  */
 export type AdminRecord = Record<string, unknown>;
 /**
@@ -443,7 +539,8 @@ export type AdminRecord = Record<string, unknown>;
 export interface RecordPermissions {
     update: boolean;
     delete: boolean;
-    actions?: string[];
+    /** Record actions by name: the label to show on this record (`label.for`, else the action's label), or `false` when it may not run here. */
+    actions?: Record<string, string | false>;
 }
 /** `POST /resources/:resource/bulk-delete` with `{ ids }` (encoded record ids): each id succeeds or fails on its own. */
 export interface BulkResult {
@@ -528,6 +625,11 @@ export interface SessionResponse {
         enabled: boolean;
         view: boolean;
     };
+    /** With `appearance`: the admin-wide accent colour (null: the host's branding), and whether this user may change it. */
+    appearance?: {
+        accent: string | null;
+        manage: boolean;
+    };
     /** Changes when roles or memberships change: refetch meta and schemas. */
     permissionsVersion: number;
     /** A superuser looking through another user's eyes (`X-View-As`): `user` is the target, `by` the superuser. Read-only. */
@@ -825,6 +927,137 @@ export interface AuditResponse {
 }
 /** A label in one language, or per language (`{ en: 'Orders', fa: 'سفارش‌ها' }`). */
 export type LocalizedLabel = string | Record<string, string>;
+/** A status colour of the design (badges, computed cells, stat changes). */
+export type Tone = 'ok' | 'warn' | 'bad' | 'info' | 'neutral' | 'primary';
+/**
+ * An aside card (spec §5.6). Own fields come from the record; a relation card's from `_aside[index]` (the related
+ * record's fields this user may see, with its `_id`, absent when they may not see it), linking to it when `link`.
+ */
+export interface AsideCardSchema {
+    title: string;
+    icon?: string;
+    fields: string[];
+    relation?: {
+        field: string;
+        resource: string;
+        link: boolean;
+    };
+}
+/** Dashboard widgets (spec §5.8). */
+export type WidgetType = 'stat' | 'chart' | 'table' | 'progress' | 'list';
+/**
+ * The period a widget is asked for, computed by the UI in the browser's time zone (Jalali-aware): ISO instants, `to`
+ * excluded, and the window before it for comparisons. The server checks `from < to` and a span of at most 366 days.
+ */
+export interface WidgetParams {
+    period: 'day' | 'week' | 'month' | 'year' | 'range';
+    from: string;
+    to: string;
+    previousFrom: string;
+    previousTo: string;
+}
+/** `GET /api/dashboard`: the widgets this user may see, in order. */
+export interface DashboardResponse {
+    widgets: Array<{
+        name: string;
+        type: WidgetType;
+        title: string;
+        size: 1 | 2 | 3 | 4;
+    }>;
+}
+export interface StatWidgetData {
+    /** Already formatted by the host or a plain number as text (the UI formats digits). */
+    value: string;
+    unit?: string;
+    /** Percent against the previous period. */
+    change?: number;
+    previousLabel?: string;
+}
+export interface ChartWidgetData {
+    kind: 'bar' | 'line';
+    labels: string[];
+    series: Array<{
+        label: string;
+        values: number[];
+        dashed?: boolean;
+    }>;
+    total?: string;
+    subtitle?: string;
+}
+export interface TableWidgetData {
+    columns: Array<{
+        key: string;
+        label: string;
+    }>;
+    /** Cell values by column key; a `{ label, tone }` cell is a status badge. */
+    rows: Array<Record<string, string | number | {
+        label: string;
+        tone: Tone;
+    }>>;
+    /** «View all»: the list with this filter. */
+    link?: {
+        resource: string;
+        filter?: Record<string, string>;
+    };
+}
+export interface ProgressWidgetData {
+    percent: number;
+    value: string;
+    caption: string;
+}
+export interface ListWidgetData {
+    items: Array<{
+        icon?: string;
+        text: string;
+        status?: Tone;
+        link?: string;
+    }>;
+}
+/** `GET /api/dashboard/:widget`: the data of the widget's type. */
+export type WidgetData = StatWidgetData | ChartWidgetData | TableWidgetData | ProgressWidgetData | ListWidgetData;
+/** A list tab (spec §5.5). */
+export interface ListTabSchema {
+    key: string;
+    label: string;
+    /** `filter[...]` list parameters the tab sets (none: «all»). */
+    filter: Record<string, string>;
+    /** The tab restricts the list beyond its filters: send `tab=<key>`. */
+    where: boolean;
+    count: 'exact' | 'estimate' | 'none';
+}
+/** `GET /api/resources/:resource/tab-counts`: each tab's count for the viewer, `null` for `count: 'none'`. */
+export type TabCounts = Record<string, {
+    count: number;
+    estimate: boolean;
+} | null>;
+/** A computed list column (spec §5.4). */
+export interface ComputedColumnSchema {
+    label: string;
+    kind: 'image' | 'title' | 'money' | 'badge' | 'count' | 'toggle';
+    sortable: boolean;
+    /** `toggle`: the enum field a click writes (PATCH `{ [field]: on | off }`), when the viewer may edit it. */
+    toggle?: {
+        field: string;
+        on: string;
+        off: string;
+    };
+}
+/**
+ * A computed cell's value (`AdminRecord._computed[key]`): `value` is the main one (an image is its URL, a toggle
+ * a boolean), `subline` and `previous` go with `title` and `money`, `label` and `tone` with `badge`.
+ */
+export interface ComputedValue {
+    value: unknown;
+    subline?: unknown;
+    previous?: unknown;
+    label?: string;
+    tone?: Tone;
+}
+/** A money unit as shown: `۳٬۲۵۰٬۰۰۰ تومان` (after) or `$12.50` (before). */
+export interface CurrencyDisplay {
+    unit: string;
+    position: 'after' | 'before';
+}
 /** Host branding (spec §9.5). Colours and lengths are validated by core before they reach the page. */
 export interface BrandingConfig {
     name?: LocalizedLabel;
@@ -843,4 +1076,9 @@ export interface AdminRuntimeConfig {
     locale: string;
     locales: string[];
     branding: BrandingConfig;
+    /** The global money unit, in every configured language (the UI picks its own). */
+    currency?: {
+        unit: LocalizedLabel;
+        position: 'after' | 'before';
+    };
 }

package/dist/crud/computed-columns.d.ts

@@ -0,0 +1,65 @@
+import type { EntityMetadata, ObjectLiteral, SelectQueryBuilder } from 'typeorm';
+import type { ComputedValue, FieldSchema } from '../contract.js';
+import type { LocalizedText } from '../i18n/localized-text.js';
+import type { AdminContext } from '../resource/admin-context.js';
+import type { ComputedColumn } from '../resource/admin-resource-base.js';
+type RelationMeta = EntityMetadata['relations'][number];
+/** A source once checked against the entity: what to read and how. */
+export type CompiledSource = {
+    type: 'field';
+    path: string;
+} | {
+    type: 'aggregate';
+    fn: 'min' | 'max' | 'sum' | 'count';
+    relation: RelationMeta;
+    field?: string;
+} | {
+    type: 'first';
+    relation: RelationMeta;
+    field: string;
+    by: string;
+} | {
+    type: 'toggle';
+    field: string;
+    on: string;
+    off: string;
+} | {
+    type: 'compute';
+    fn: (rows: any[], ctx: AdminContext) => Promise<Record<string, unknown>>;
+    fields: string[];
+};
+export interface CompiledComputed {
+    key: string;
+    column: ComputedColumn;
+    source: CompiledSource;
+    subline?: CompiledSource;
+    previous?: CompiledSource;
+    /** What it reads, for the policy: own fields and paths, and the child entities (and their fields) it aggregates. */
+    deps: {
+        own: string[];
+        children: Array<{
+            entity: Function;
+            fields: string[];
+        }>;
+    };
+}
+/**
+ * Checks `list.computed` at boot (spec §5.4) and compiles each column: sources exist, relations are one-to-many of a
+ * single-key entity, `sortable` only on aggregates and first rows, a toggle's values are its enum's, `map` only on badges.
+ */
+export declare function checkComputed(computed: Record<string, ComputedColumn> | undefined, metadata: EntityMetadata, enumValues: (field: string) => string[] | undefined, fail: (message: string) => never): Map<string, CompiledComputed>;
+/** A query of a child entity as the viewer may read it (the child resource's `query()` and scopes), or a plain one. */
+export type ChildQuery = (entity: Function, alias: string, ctx: AdminContext | undefined) => SelectQueryBuilder<ObjectLiteral>;
+/**
+ * The page's computed values, by record id: one query per relation or path source and one `compute` call, whatever the
+ * page size (no N+1). Badge labels are localized with `text`.
+ */
+export declare function loadComputed(columns: CompiledComputed[], rows: ObjectLiteral[], metadata: EntityMetadata, ctx: AdminContext, childQuery: ChildQuery, pathQuery: (alias: string) => SelectQueryBuilder<ObjectLiteral>, text: (label: LocalizedText) => string, 
+/** A field's schema (to serialize decimals as strings, dates as ISO…): the entity's resource field, if any. */
+fieldFor: (entity: Function, name: string) => FieldSchema | undefined): Promise<Map<string, Record<string, ComputedValue>>>;
+/**
+ * Sorting by an aggregate or first-row column: a correlated subquery over the rows the viewer may read, selected as
+ * `nma_sort` so paging with joins can order by it. Returns the expression to order by.
+ */
+export declare function addComputedSort(qb: SelectQueryBuilder<ObjectLiteral>, compiled: CompiledComputed, metadata: EntityMetadata, ctx: AdminContext | undefined, childQuery: ChildQuery): string;
+export {};

package/dist/crud/computed-columns.js

@@ -0,0 +1,264 @@
+import { resolvePath } from '../schema/relation-fields.js';
+import { recordIdOf } from './record-id.js';
+import { serializeValue } from './serialize.js';
+const KINDS = ['image', 'title', 'money', 'badge', 'count', 'toggle'];
+const AGGREGATES = ['min', 'max', 'sum', 'count'];
+/**
+ * Checks `list.computed` at boot (spec §5.4) and compiles each column: sources exist, relations are one-to-many of a
+ * single-key entity, `sortable` only on aggregates and first rows, a toggle's values are its enum's, `map` only on badges.
+ */
+export function checkComputed(computed, metadata, enumValues, fail) {
+    const out = new Map();
+    for (const [key, column] of Object.entries(computed ?? {})) {
+        const where = `list.computed.${key}`;
+        if (!KINDS.includes(column.kind))
+            fail(`${where}: unknown kind "${String(column.kind)}" (use ${KINDS.join(', ')})`);
+        const deps = { own: [], children: [] };
+        const compile = (source, part) => compileSource(source, `${where}.${part}`, metadata, enumValues, deps, fail);
+        const source = compile(column.source, 'source');
+        if (column.sortable && source.type !== 'aggregate' && source.type !== 'first')
+            fail(`${where}: only aggregate and first sources can be sortable`);
+        if (column.map !== undefined && (column.kind !== 'badge' || typeof column.map !== 'function'))
+            fail(`${where}: \`map\` is a function, for badges only`);
+        if ((column.kind === 'toggle') !== (source.type === 'toggle'))
+            fail(`${where}: a toggle column needs a { toggle, on, off } source, and only it`);
+        if (column.subline !== undefined && column.kind !== 'title')
+            fail(`${where}: \`subline\` goes with the title kind`);
+        if (column.previous !== undefined && column.kind !== 'money')
+            fail(`${where}: \`previous\` goes with the money kind`);
+        out.set(key, {
+            key,
+            column,
+            source,
+            ...(column.subline !== undefined ? { subline: compile(column.subline, 'subline') } : {}),
+            ...(column.previous !== undefined ? { previous: compile(column.previous, 'previous') } : {}),
+            deps,
+        });
+    }
+    return out;
+}
+function compileSource(source, where, metadata, enumValues, deps, fail) {
+    const ownField = (name, what) => {
+        if (!metadata.findColumnsWithPropertyPath(name).length && !metadata.relations.some((relation) => relation.propertyName === name))
+            fail(`${where}: unknown ${what} "${name}" on ${metadata.name}`);
+        deps.own.push(name);
+    };
+    const toMany = (name) => {
+        if (metadata.primaryColumns.length !== 1)
+            fail(`${where}: relation sources need an entity with one primary key column`);
+        const relation = metadata.relations.find((candidate) => candidate.propertyName === name);
+        if (!relation)
+            fail(`${where}: unknown relation "${name}" on ${metadata.name}`);
+        if (relation.relationType !== 'one-to-many' || !relation.inverseRelation)
+            fail(`${where}: "${name}" is not a one-to-many relation`);
+        return relation;
+    };
+    const childField = (relation, name) => {
+        const child = relation.inverseEntityMetadata;
+        if (!child.findColumnsWithPropertyPath(name).length)
+            fail(`${where}: unknown field "${name}" on ${child.name}`);
+        const entry = deps.children.find((candidate) => candidate.entity === child.target);
+        if (entry)
+            entry.fields.push(name);
+        else
+            deps.children.push({ entity: child.target, fields: [name] });
+    };
+    if (typeof source === 'string') {
+        if (source.includes('.')) {
+            const resolved = resolvePath(metadata, source);
+            if ('error' in resolved)
+                fail(`${where}: cannot use "${source}": ${resolved.error}`);
+            deps.own.push(source);
+        }
+        else
+            ownField(source, 'field');
+        return { type: 'field', path: source };
+    }
+    if ('aggregate' in source) {
+        if (!AGGREGATES.includes(source.aggregate))
+            fail(`${where}: unknown aggregate "${String(source.aggregate)}"`);
+        const relation = toMany(source.relation);
+        if (source.aggregate !== 'count' && !source.field)
+            fail(`${where}: ${source.aggregate} needs a field`);
+        if (source.field)
+            childField(relation, source.field);
+        else if (!deps.children.some((entry) => entry.entity === relation.inverseEntityMetadata.target))
+            deps.children.push({ entity: relation.inverseEntityMetadata.target, fields: [] });
+        return { type: 'aggregate', fn: source.aggregate, relation, ...(source.field ? { field: source.field } : {}) };
+    }
+    if ('first' in source) {
+        const relation = toMany(source.first);
+        childField(relation, source.field);
+        childField(relation, source.by);
+        return { type: 'first', relation, field: source.field, by: source.by };
+    }
+    if ('toggle' in source) {
+        ownField(source.toggle, 'field');
+        const values = enumValues(source.toggle);
+        if (!values)
+            fail(`${where}: "${source.toggle}" is not an enum field`);
+        for (const value of [source.on, source.off])
+            if (!values.includes(value))
+                fail(`${where}: "${value}" is not one of ${values.join(', ')}`);
+        return { type: 'toggle', field: source.toggle, on: source.on, off: source.off };
+    }
+    if ('compute' in source) {
+        if (typeof source.compute !== 'function')
+            fail(`${where}: compute must be a function`);
+        if (!Array.isArray(source.fields))
+            fail(`${where}: compute needs \`fields\`, the fields it reads (a viewer who cannot see one does not get the column)`);
+        for (const field of source.fields)
+            ownField(field, 'field');
+        return { type: 'compute', fn: source.compute, fields: source.fields };
+    }
+    return fail(`${where}: unknown source`);
+}
+/**
+ * The page's computed values, by record id: one query per relation or path source and one `compute` call, whatever the
+ * page size (no N+1). Badge labels are localized with `text`.
+ */
+export async function loadComputed(columns, rows, metadata, ctx, childQuery, pathQuery, text, 
+/** A field's schema (to serialize decimals as strings, dates as ISO…): the entity's resource field, if any. */
+fieldFor) {
+    const keys = metadata.primaryColumns.map((column) => column.propertyName);
+    const out = new Map(rows.map((row) => [recordIdOf(row, keys), {}]));
+    if (rows.length === 0 || columns.length === 0)
+        return out;
+    const pk = keys[0];
+    const ids = rows.map((row) => row[pk]);
+    const cache = new Map();
+    const resolve = (source) => {
+        const id = sourceId(source);
+        let found = cache.get(id);
+        if (!found)
+            cache.set(id, (found = read(source)));
+        return found;
+    };
+    const read = async (source) => {
+        const raw = await readRaw(source);
+        const field = source.type === 'field'
+            ? fieldFor(metadata.target, source.path)
+            : source.type === 'first' || (source.type === 'aggregate' && source.fn !== 'count' && source.field)
+                ? fieldFor(source.relation.inverseEntityMetadata.target, source.field)
+                : undefined;
+        if (!field)
+            return raw;
+        // Drivers answer SUM/MIN/MAX of an integer as text (Postgres bigint): a number field stays a number.
+        const typed = (value) => (field.type === 'number' && typeof value === 'string' && value.trim() !== '' && !Number.isNaN(Number(value)) ? Number(value) : value);
+        return new Map([...raw].map(([id, value]) => [id, serializeValue(typed(value), field)]));
+    };
+    const readRaw = async (source) => {
+        const byRow = new Map();
+        switch (source.type) {
+            case 'field': {
+                if (!source.path.includes('.')) {
+                    for (const row of rows)
+                        byRow.set(recordIdOf(row, keys), row[source.path] ?? null);
+                    return byRow;
+                }
+                const qb = pathQuery('nma_p');
+                const segments = source.path.split('.');
+                let alias = 'nma_p';
+                segments.slice(0, -1).forEach((segment, index) => {
+                    qb.leftJoin(`${alias}.${segment}`, `nma_j${index}`);
+                    alias = `nma_j${index}`;
+                });
+                const raw = await qb.select(`nma_p.${pk}`, 'k').addSelect(`${alias}.${segments.at(-1)}`, 'v').where(`nma_p.${pk} IN (:...nmaIds)`, { nmaIds: ids }).getRawMany();
+                for (const { k, v } of raw)
+                    byRow.set(String(k), v ?? null);
+                return byRow;
+            }
+            case 'aggregate': {
+                const child = source.relation.inverseEntityMetadata;
+                const fk = `nma_c.${source.relation.inverseRelation.propertyName}`;
+                const target = source.field ? `nma_c.${source.field}` : `nma_c.${child.primaryColumns[0].propertyName}`;
+                const raw = await childQuery(child.target, 'nma_c', ctx)
+                    .select(fk, 'k')
+                    .addSelect(`${source.fn.toUpperCase()}(${target})`, 'v')
+                    .andWhere(`${fk} IN (:...nmaIds)`, { nmaIds: ids })
+                    .groupBy(fk)
+                    .getRawMany();
+                for (const { k, v } of raw)
+                    byRow.set(String(k), source.fn === 'count' ? Number(v) : v);
+                if (source.fn === 'count')
+                    for (const row of rows)
+                        if (!byRow.has(recordIdOf(row, keys)))
+                            byRow.set(recordIdOf(row, keys), 0);
+                return byRow;
+            }
+            case 'first': {
+                const child = source.relation.inverseEntityMetadata;
+                const fk = `nma_c.${source.relation.inverseRelation.propertyName}`;
+                const raw = await childQuery(child.target, 'nma_c', ctx)
+                    .select(fk, 'k')
+                    .addSelect(`nma_c.${source.field}`, 'v')
+                    .andWhere(`${fk} IN (:...nmaIds)`, { nmaIds: ids })
+                    .orderBy(`nma_c.${source.by}`, 'ASC')
+                    .addOrderBy(`nma_c.${child.primaryColumns[0].propertyName}`, 'ASC')
+                    .getRawMany();
+                for (const { k, v } of raw)
+                    if (!byRow.has(String(k)))
+                        byRow.set(String(k), v ?? null);
+                return byRow;
+            }
+            case 'toggle':
+                for (const row of rows)
+                    byRow.set(recordIdOf(row, keys), row[source.field] === source.on);
+                return byRow;
+            case 'compute': {
+                const values = await source.fn(rows, ctx);
+                for (const row of rows)
+                    byRow.set(recordIdOf(row, keys), values[recordIdOf(row, keys)] ?? null);
+                return byRow;
+            }
+        }
+    };
+    for (const compiled of columns) {
+        const [main, subline, previous] = await Promise.all([resolve(compiled.source), compiled.subline && resolve(compiled.subline), compiled.previous && resolve(compiled.previous)]);
+        for (const row of rows) {
+            const id = recordIdOf(row, keys);
+            const value = main.get(id) ?? null;
+            const cell = { value };
+            if (subline)
+                cell.subline = subline.get(id) ?? null;
+            if (previous)
+                cell.previous = previous.get(id) ?? null;
+            if (compiled.column.map) {
+                const mapped = compiled.column.map(value, row);
+                cell.label = text(mapped.label);
+                cell.tone = mapped.tone;
+            }
+            out.get(id)[compiled.key] = cell;
+        }
+    }
+    return out;
+}
+const sourceId = (source) => source.type === 'field'
+    ? `f:${source.path}`
+    : source.type === 'aggregate'
+        ? `a:${source.fn}:${source.relation.propertyName}:${source.field ?? ''}`
+        : source.type === 'first'
+            ? `1:${source.relation.propertyName}:${source.field}:${source.by}`
+            : source.type === 'toggle'
+                ? `t:${source.field}`
+                : `c:${Math.random()}`; // each compute function runs once anyway
+/**
+ * Sorting by an aggregate or first-row column: a correlated subquery over the rows the viewer may read, selected as
+ * `nma_sort` so paging with joins can order by it. Returns the expression to order by.
+ */
+export function addComputedSort(qb, compiled, metadata, ctx, childQuery) {
+    const source = compiled.source;
+    if (source.type !== 'aggregate' && source.type !== 'first')
+        throw new Error(`nest-my-admin: ${compiled.key} is not sortable`);
+    const child = source.relation.inverseEntityMetadata;
+    const childPk = child.primaryColumns[0].propertyName;
+    const sub = childQuery(child.target, 'nma_s', ctx).andWhere(`nma_s.${source.relation.inverseRelation.propertyName} = ${qb.alias}.${metadata.primaryColumns[0].propertyName}`);
+    // A sum over no rows is 0, not NULL: drivers place NULLs differently when sorting (first in Postgres descending).
+    if (source.type === 'aggregate')
+        sub.select(source.fn === 'sum' ? `COALESCE(SUM(nma_s.${source.field}), 0)` : `${source.fn.toUpperCase()}(nma_s.${source.field ?? childPk})`);
+    else
+        sub.select(`nma_s.${source.field}`).orderBy(`nma_s.${source.by}`, 'ASC').addOrderBy(`nma_s.${childPk}`, 'ASC').limit(1);
+    qb.addSelect(`(${sub.getQuery()})`, 'nma_sort').setParameters({ ...qb.getParameters(), ...sub.getParameters() });
+    return 'nma_sort';
+}
+//# sourceMappingURL=computed-columns.js.map