@svgrid/enterprise 3.1.7 → 3.1.9

package/dist/fields/automations.svelte.js

@@ -0,0 +1,437 @@
+/**
+ * Automations: "when this happens to a record, do these things", per table
+ * of a base.
+ *
+ * A trigger names the moment (a record created, a field changed, a record
+ * that starts matching a condition, a form sent, a button pressed, a time of
+ * day). An optional condition, written with the view bar's filter, narrows it
+ * to some records. The actions then run in order: change the record, create a
+ * record in any table (linked back to this one if you like), show a notice,
+ * color the record while it matches, or run a function the app registered.
+ *
+ * Automations run in the page of the person who made the change, once: a
+ * change that arrives from another person (realtime) does not set them off
+ * here. A change an automation makes can set off other automations, up to
+ * `MAX_DEPTH` deep, so two that answer each other stop instead of looping.
+ * Every run is kept in a short history, with what each action did.
+ */
+import { toast } from '@svgrid/grid';
+import { createScheduler } from '../scheduling.js';
+import { colId, primaryOf, rowIdOf, syncAllInverses } from './base-tables.js';
+import { compileFieldFilter, describeFieldFilter } from './filter-model.js';
+import { fieldPropsOf, fillFieldColumn } from './registry.svelte.js';
+import { noteChange } from './activity.svelte.js';
+import { getFieldUsers } from './sources.svelte.js';
+import { newRecordId } from './field-ops.js';
+import { fieldText, fieldValue, linkNames } from './base-alerts.js';
+import { callWebhook, sendEmailAction } from './automation-outbound.js';
+const appActions = new Map();
+/**
+ * Add an action automations can run: a webhook, an email, a message to chat.
+ * It runs in the page; keep secrets on your server and call it from here.
+ */
+export function registerAutomationAction(id, action) {
+    appActions.set(id, action);
+}
+export function listAutomationActions() {
+    return [...appActions].map(([id, a]) => ({ id, label: a.label }));
+}
+// ---- Reading a table outside its grid ----------------------------------------------
+const readers = new WeakMap();
+/** A table's fields as filled in (formulas, lookups, formats), by column id. */
+export function tableFields(t) {
+    const hit = readers.get(t.columns);
+    if (hit)
+        return hit;
+    const all = t.columns.map((d) => ({ ...d, id: colId(d) }));
+    const map = new Map();
+    for (const d of t.columns) {
+        if (d.field == null)
+            continue;
+        const def = fillFieldColumn(d, all);
+        map.set(colId(d), { id: colId(d), field: String(d.field), header: String(d.header ?? d.field), fieldType: d.fieldType, def, visible: true });
+    }
+    readers.set(t.columns, map);
+    return map;
+}
+/** A field by a header, its key or its id, ignoring case and outer spaces, as a formula's `{name}` matches one. */
+const byName = (t, name) => {
+    const lower = name.trim().toLowerCase();
+    for (const c of tableFields(t).values()) {
+        if (c.header.trim().toLowerCase() === lower || c.field.toLowerCase() === lower || c.id.toLowerCase() === lower)
+            return c;
+    }
+    return undefined;
+};
+/** `{Field name}` tokens of a template, filled from a record. */
+export function fillTokens(t, record, template) {
+    return template.replace(/\{([^{}\n]+)\}/g, (m, name) => {
+        if (!record)
+            return m;
+        const c = byName(t, name);
+        return c ? fieldText(c, record) : m;
+    });
+}
+/** Whether a record matches a condition (no condition matches every record). */
+export function matches(t, condition, record) {
+    if (!condition)
+        return true;
+    const fields = tableFields(t);
+    const test = compileFieldFilter(condition, (row, id) => {
+        const c = fields.get(id);
+        return c ? fieldValue(c, row) : row[id];
+    }, linkNames);
+    return test ? test(record) : true;
+}
+/**
+ * Last modified time fields of a record an automation changed, as an edit
+ * stamps them. Last modified by names a person, so it keeps its author.
+ */
+function stampModifiedTime(t, row, changedIds, at) {
+    for (const d of t.columns) {
+        if (d.fieldType !== 'lastModifiedTime' || d.field == null || changedIds.includes(colId(d)))
+            continue;
+        const p = fieldPropsOf(d);
+        if (p.watch === 'specific' && !changedIds.some((id) => (p.watchFields ?? []).includes(id)))
+            continue;
+        row[String(d.field)] = at.toISOString();
+    }
+}
+// ---- Values -----------------------------------------------------------------------
+const DAY = 86400000;
+const isoDay = (d) => `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, '0')}-${String(d.getDate()).padStart(2, '0')}`;
+/** What a value written in an action becomes in a field of `t`. */
+export function fieldValueFrom(t, def, spec, ctx) {
+    const type = def.fieldType;
+    if (typeof spec !== 'string')
+        return spec;
+    const raw = spec.includes('{record}') ? spec : fillTokens(ctx.from, ctx.record, spec);
+    const text = raw.trim();
+    if (text === '')
+        return type === 'checkbox' ? false : type === 'multiSelect' || type === 'link' || type === 'attachment' ? [] : null;
+    switch (type) {
+        case 'checkbox':
+            return /^(true|yes|1|checked|on)$/i.test(text);
+        case 'number':
+        case 'rating':
+        case 'duration':
+        case 'currency':
+        case 'percent': {
+            const n = Number(text.replace(/[^0-9.+-eE]/g, ''));
+            // "100%" in a percent field is 1, as the field keeps it.
+            return Number.isFinite(n) ? (text.endsWith('%') ? n / 100 : n) : null;
+        }
+        case 'multiSelect':
+            return text.split(/\s*,\s*/).filter(Boolean);
+        case 'user': {
+            const found = getFieldUsers().find((u) => u.id === text || u.name.toLocaleLowerCase() === text.toLocaleLowerCase());
+            return found ? found.id : text;
+        }
+        case 'date': {
+            const m = /^(today|now)\s*(?:([+-])\s*(\d+))?$/i.exec(text);
+            if (!m)
+                return text;
+            const shift = m[2] ? (m[2] === '-' ? -1 : 1) * Number(m[3]) * DAY : 0;
+            const at = new Date(ctx.now.getTime() + shift);
+            return m[1].toLowerCase() === 'now' || def.fieldProps?.time ? at.toISOString() : isoDay(at);
+        }
+        case 'link': {
+            const target = ctx.tables.find((x) => x.id === def.fieldProps?.table);
+            const out = [];
+            for (const part of text.split(/\s*,\s*/)) {
+                if (part === '{record}') {
+                    if (ctx.record && ctx.from.id === target?.id)
+                        out.push(rowIdOf(ctx.from, ctx.record));
+                    continue;
+                }
+                const name = fillTokens(ctx.from, ctx.record, part).toLocaleLowerCase();
+                const hit = target?.data.find((r) => String(r?.[primaryOf(target)] ?? '').toLocaleLowerCase() === name);
+                if (hit && target)
+                    out.push(rowIdOf(target, hit));
+            }
+            return def.fieldProps?.multiple === false ? out.slice(0, 1) : out;
+        }
+        default:
+            return raw;
+    }
+}
+/** The longest chain of automations setting each other off. */
+export const MAX_DEPTH = 4;
+let runSeq = 0;
+export function createAutomationRunner(options) {
+    const now = options.now ?? (() => new Date());
+    let runs = $state.raw([]);
+    let scheduler = null;
+    let chain = Promise.resolve();
+    const record = (run) => (runs = [run, ...runs].slice(0, 100));
+    const automationsOf = (t) => (t.automations ?? []).filter((a) => a.enabled && a.runOn !== 'server');
+    const tableOf = (id) => options.getTables()?.find((t) => t.id === id);
+    const recordNow = (t, id) => tableOf(t.id)?.data.find((r) => r && rowIdOf(t, r) === id) ?? null;
+    const setOff = (t, e) => automationsFor(t, e, 'browser');
+    /** Hear of something that happened to a record; the automations it sets off run in order. */
+    function handle(e) {
+        const t = tableOf(e.table);
+        if (!t)
+            return chain;
+        const list = setOff(t, e);
+        const depth = 'depth' in e ? (e.depth ?? 0) : 0;
+        for (const a of list)
+            chain = chain.then(() => runOne(a, t.id, rowIdOf(t, e.record), depth));
+        return chain;
+    }
+    async function runOne(a, tableId, recordId, depth) {
+        const t = tableOf(tableId);
+        if (!t)
+            return;
+        const rec = recordId == null ? null : recordNow(t, recordId);
+        const run = { id: ++runSeq, automationId: a.id, name: a.name, table: t.name, record: rec ? String(rec[primaryOf(t)] ?? recordId) : null, at: now().getTime(), status: 'ok', steps: [] };
+        if (depth >= MAX_DEPTH) {
+            run.status = 'stopped';
+            run.steps.push({ action: 'Stopped', detail: `Automations set each other off ${MAX_DEPTH} times in a row; this one did not run, so they cannot loop.` });
+            record(run);
+            return;
+        }
+        for (const action of a.actions) {
+            try {
+                const step = await act(a, action, tableId, recordId, depth);
+                if (step)
+                    run.steps.push(step);
+            }
+            catch (e) {
+                run.status = 'error';
+                run.steps.push({ action: actionLabel(action), detail: '', error: e instanceof Error ? e.message : String(e) });
+                break;
+            }
+        }
+        record(run);
+    }
+    async function act(a, action, tableId, recordId, depth) {
+        const tables = options.getTables() ?? [];
+        const t = tables.find((x) => x.id === tableId);
+        const rec = recordId == null ? null : (t.data.find((r) => r && rowIdOf(t, r) === recordId) ?? null);
+        const ctx = { tables, from: t, record: rec, now: now() };
+        switch (action.type) {
+            case 'notify': {
+                const message = fillTokens(t, rec, action.message);
+                const sev = action.severity ?? 'info';
+                toast[sev](message);
+                return { action: 'Notice', detail: message };
+            }
+            case 'highlight':
+                // Drawn by the grid while the record matches; nothing to do now.
+                return null;
+            case 'updateRecord': {
+                if (!rec || recordId == null)
+                    return { action: 'Update record', detail: 'No record to update' };
+                const fields = tableFields(t);
+                const patch = {};
+                for (const [id, spec] of Object.entries(action.values)) {
+                    const c = fields.get(id);
+                    if (c)
+                        patch[c.field] = fieldValueFrom(t, c.def, spec, ctx);
+                }
+                const before = { ...rec };
+                const after = { ...rec, ...patch };
+                const changed = Object.keys(patch).filter((f) => JSON.stringify(before[f] ?? null) !== JSON.stringify(after[f] ?? null));
+                if (!changed.length)
+                    return { action: 'Update record', detail: 'Already set' };
+                const changedIds = changed.map((f) => [...fields.values()].find((c) => c.field === f)?.id ?? f);
+                stampModifiedTime(t, after, changedIds, ctx.now);
+                let next = tables.map((x) => (x.id === t.id ? { ...x, data: x.data.map((r) => (r === rec ? after : r)) } : x));
+                next = syncAllInverses(next, t.id);
+                options.apply(next, depth + 1, t.id);
+                // The record's activity says the automation made the change.
+                changed.forEach((f, i) => noteChange({ base: options.scope, tableId: t.id }, recordId, changedIds[i], after[f], a.name));
+                // What it changed can set off other automations, one level deeper.
+                void handle({ type: 'updated', table: t.id, record: after, before, fields: changedIds, depth: depth + 1 });
+                return { action: 'Update record', detail: changed.map((f) => said([...fields.values()].find((c) => c.field === f), f, after)).join(', ') };
+            }
+            case 'createRecord': {
+                const target = tables.find((x) => x.id === action.table);
+                if (!target)
+                    throw new Error(`No table "${action.table}"`);
+                const fields = tableFields(target);
+                const row = { id: newRecordId() };
+                for (const [id, spec] of Object.entries(action.values)) {
+                    const c = fields.get(id);
+                    if (c)
+                        row[c.field] = fieldValueFrom(target, c.def, spec, ctx);
+                }
+                if (action.linkField && rec) {
+                    const c = fields.get(action.linkField);
+                    if (c)
+                        row[c.field] = [rowIdOf(t, rec)];
+                }
+                let next = tables.map((x) => (x.id === target.id ? { ...x, data: [...x.data, row] } : x));
+                next = syncAllInverses(next, target.id);
+                options.apply(next, depth + 1, target.id);
+                void handle({ type: 'created', table: target.id, record: row, depth: depth + 1 });
+                const name = String(row[primaryOf(target)] ?? '') || 'a record';
+                return { action: 'Create record', detail: `${name} in ${target.name}` };
+            }
+            case 'run':
+                return runAppAction(a, action, t, rec);
+            case 'webhook':
+                return { action: 'Webhook', detail: await callWebhook(action, outbound(a, t, rec)) };
+            case 'email':
+                // The browser has no mail sender: this fails and says to run it on the server.
+                return { action: 'Email', detail: await sendEmailAction(action, outbound(a, t, rec), undefined) };
+        }
+    }
+    /** Run the scheduled automations of every table again from now on (after a change to them). */
+    function schedule() {
+        scheduler?.stop();
+        scheduler = null;
+        const list = options.getTables() ?? [];
+        const due = [];
+        for (const t of list)
+            for (const a of automationsOf(t))
+                if (a.trigger.type === 'scheduled')
+                    due.push({ id: `${t.id}:${a.id}`, cron: a.trigger.cron, table: t.id, automation: a });
+        if (!due.length)
+            return;
+        scheduler = createScheduler({
+            schedules: due,
+            now,
+            onFire: (s) => void runScheduled(s.id),
+        });
+        scheduler.start();
+    }
+    /** A scheduled automation, now: once per record matching its condition, or once with no record. */
+    function runScheduled(key) {
+        const [tableId, automationId] = key.split(':');
+        const t = tableOf(tableId);
+        const a = t?.automations?.find((x) => x.id === automationId);
+        if (!t || !a)
+            return chain;
+        if (!a.condition)
+            chain = chain.then(() => runOne(a, t.id, null, 0));
+        else
+            for (const r of t.data)
+                if (r && matches(t, a.condition, r))
+                    chain = chain.then(() => runOne(a, t.id, rowIdOf(t, r), 0));
+        return chain;
+    }
+    return {
+        handle,
+        schedule,
+        runScheduled,
+        /** Run one automation now for a record (or none), as its trigger would. */
+        /** Run one automation now for a record (or none), as its trigger would; a record that does not match its condition is reported, not run. */
+        runNow: (a, tableId, recordId) => (chain = chain.then(() => {
+            const t = tableOf(tableId);
+            const rec = t && recordId != null ? recordNow(t, recordId) : null;
+            if (t && rec && a.condition && !matches(t, a.condition, rec)) {
+                record({ id: ++runSeq, automationId: a.id, name: a.name, table: t.name, record: String(rec[primaryOf(t)] ?? recordId), at: now().getTime(), status: 'stopped', steps: [{ action: 'Not run', detail: 'The record does not match the condition' }] });
+                return;
+            }
+            return runOne(a, tableId, recordId, 0);
+        })),
+        get runs() {
+            return runs;
+        },
+        clearRuns: () => (runs = []),
+        settled: () => chain,
+        stop: () => scheduler?.stop(),
+    };
+}
+// ---- Words --------------------------------------------------------------------------
+/** "Status: Done", "Done: checked": a field of a record as a run lists it. */
+function said(c, field, record) {
+    if (!c)
+        return `${field}: ${String(record[field] ?? '')}`;
+    if (c.fieldType === 'checkbox')
+        return `${c.header}: ${record[c.field] ? 'checked' : 'unchecked'}`;
+    return `${c.header}: ${fieldText(c, record) || 'empty'}`;
+}
+/** Which of a table's automations an event sets off, for the runner on one side. */
+export function automationsFor(t, e, side) {
+    return (t.automations ?? []).filter((a) => {
+        if (!a.enabled || (a.runOn === 'server') !== (side === 'server'))
+            return false;
+        const tr = a.trigger;
+        switch (tr.type) {
+            case 'recordCreated':
+                return e.type === 'created' && matches(t, a.condition, e.record);
+            case 'recordUpdated':
+                return e.type === 'updated' && (!tr.fields?.length || tr.fields.some((f) => e.fields.includes(f))) && matches(t, a.condition, e.record);
+            case 'recordMatches':
+                if (!a.condition)
+                    return false;
+                if (e.type === 'created')
+                    return matches(t, a.condition, e.record);
+                if (e.type === 'updated')
+                    return matches(t, a.condition, e.record) && !matches(t, a.condition, e.before);
+                return false;
+            case 'formSubmitted':
+                return e.type === 'form' && (!tr.view || tr.view === e.view) && matches(t, a.condition, e.record);
+            case 'button':
+                return e.type === 'button' && e.field === tr.field && matches(t, a.condition, e.record);
+            default:
+                return false;
+        }
+    });
+}
+/** What a webhook or an email reads of the record. */
+export function outbound(a, t, rec, extra = {}) {
+    return {
+        automation: a.name,
+        table: t.name,
+        record: rec,
+        fill: (template) => fillTokens(t, rec, template),
+        fields: () => {
+            const out = {};
+            if (rec)
+                for (const c of tableFields(t).values())
+                    out[c.header] = c.fieldType === 'checkbox' ? String(!!rec[c.field]) : fieldText(c, rec);
+            return out;
+        },
+        ...extra,
+    };
+}
+/** An action the app registered, run on a record. */
+export async function runAppAction(a, action, t, rec) {
+    const app = appActions.get(action.action);
+    if (!app)
+        throw new Error(`No action "${action.action}" is registered`);
+    const out = await app.run({ automation: a, table: t, record: rec, text: (name) => fillTokens(t, rec, `{${name}}`), options: action.options ?? {} });
+    return { action: app.label, detail: typeof out === 'string' ? out : 'Done' };
+}
+export function actionLabel(a) {
+    switch (a.type) {
+        case 'updateRecord':
+            return 'Update record';
+        case 'createRecord':
+            return 'Create record';
+        case 'notify':
+            return 'Show a notice';
+        case 'highlight':
+            return 'Color the record';
+        case 'run':
+            return appActions.get(a.action)?.label ?? a.action;
+        case 'webhook':
+            return 'Call a webhook';
+        case 'email':
+            return 'Send an email';
+    }
+}
+/** "When a record matches: Status is Blocked", for the list of automations. */
+export function triggerText(t, a) {
+    const name = (id) => (t ? (tableFields(t).get(id)?.header ?? id) : id);
+    const cond = a.condition ? describeFieldFilter(a.condition, name) : '';
+    const tr = a.trigger;
+    switch (tr.type) {
+        case 'recordCreated':
+            return `When a record is created${cond && cond !== 'every record' ? `, where ${cond}` : ''}`;
+        case 'recordUpdated':
+            return `When ${tr.fields?.length ? tr.fields.map(name).join(' or ') : 'a record'} changes${cond && cond !== 'every record' ? `, where ${cond}` : ''}`;
+        case 'recordMatches':
+            return `When a record matches: ${cond || 'no condition yet'}`;
+        case 'formSubmitted':
+            return `When a form is sent${cond && cond !== 'every record' ? `, where ${cond}` : ''}`;
+        case 'button':
+            return `When ${name(tr.field)} is pressed`;
+        case 'scheduled':
+            return `On a schedule (${tr.cron})${cond && cond !== 'every record' ? `, for records where ${cond}` : ''}`;
+    }
+}

package/dist/fields/bar-request.svelte.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Which view bars are mounted, and a request for one of them to open a
+ * panel. The column menu's "Filter by this field" adds a condition and asks
+ * the grid's bar to show its Filter panel; without a bar the item is not
+ * offered.
+ */
+export type BarPanel = 'hide' | 'filter' | 'group' | 'sort' | 'color' | 'chart' | 'gantt';
+/** A bar mounted over this grid; the returned function unregisters it. */
+export declare function registerBar(ctrl: object): () => void;
+export declare const hasBar: (ctrl: unknown) => boolean;
+export declare const getBarRequest: () => {
+    ctrl: unknown;
+    panel: BarPanel;
+} | null;
+export declare function openBarPanel(ctrl: unknown, panel: BarPanel): void;
+export declare function clearBarRequest(): void;

package/dist/fields/bar-request.svelte.js

@@ -0,0 +1,15 @@
+const bars = new WeakSet();
+let request = $state.raw(null);
+/** A bar mounted over this grid; the returned function unregisters it. */
+export function registerBar(ctrl) {
+    bars.add(ctrl);
+    return () => bars.delete(ctrl);
+}
+export const hasBar = (ctrl) => !!ctrl && typeof ctrl === 'object' && bars.has(ctrl);
+export const getBarRequest = () => request;
+export function openBarPanel(ctrl, panel) {
+    request = { ctrl, panel };
+}
+export function clearBarRequest() {
+    request = null;
+}

package/dist/fields/base-alerts.d.ts

@@ -0,0 +1,24 @@
+import type { PredicateExpr } from '../expressions/expression-types.js';
+import { type FieldFilter, type LinkNames } from './filter-model.js';
+import type { FieldColumn } from './grid-access.js';
+/** A link value's records by name, for a condition on a link field. */
+export declare const linkNames: LinkNames;
+/**
+ * A rule condition written as a base filter.
+ *
+ * ```ts
+ * predicate: baseCondition({ conjunction: 'and', conditions: [
+ *   { column: 'due', kind: 'date', op: 'isBefore', value: { mode: 'today' } },
+ *   { column: 'status', kind: 'select', op: 'isNot', value: 'Done' },
+ * ] })
+ * ```
+ */
+export declare function baseCondition(filter: Omit<FieldFilter, 'kind'> | FieldFilter): PredicateExpr;
+/** The base filter inside a predicate, or null when the predicate is something else. */
+export declare function baseFilterOf(expr: PredicateExpr | null | undefined): FieldFilter | null;
+/** Teach the expression language the base filter (once; `enableFields` calls it). */
+export declare function registerBaseCondition(): void;
+/** A field's value in a record: computed for a formula, lookup, rollup or count. */
+export declare function fieldValue(column: FieldColumn, row: Record<string, unknown>): unknown;
+/** A field's value as its cell shows it, as text. */
+export declare function fieldText(column: FieldColumn, row: Record<string, unknown>): string;

package/dist/fields/base-alerts.js

@@ -0,0 +1,64 @@
+/**
+ * A base condition in the expression language: the view bar's filter, kept as
+ * `{ kind: 'ext', type: 'fieldFilter', payload }`, so an alert rule or an
+ * advanced filter reads a select's option, a person, a linked record's name
+ * or "within the past week" the way the view bar does. Also the readers that
+ * give a field's value and its text outside the grid.
+ */
+import { registerPredicateKind } from '../expressions/kinds.js';
+import { compileFieldFilter, describeFieldFilter, fieldFilterColumns } from './filter-model.js';
+import { getLinkedTable, linkedRows } from './sources.svelte.js';
+/** A link value's records by name, for a condition on a link field. */
+export const linkNames = (table, value) => {
+    const t = getLinkedTable(table);
+    return t ? linkedRows(t, value).map((r) => String(r[t.primaryField] ?? '')) : [];
+};
+const EMPTY = { kind: 'fieldFilter', conjunction: 'and', conditions: [] };
+const asFilter = (payload) => {
+    const f = payload;
+    return f && Array.isArray(f.conditions) ? { ...EMPTY, ...f, kind: 'fieldFilter' } : EMPTY;
+};
+/**
+ * A rule condition written as a base filter.
+ *
+ * ```ts
+ * predicate: baseCondition({ conjunction: 'and', conditions: [
+ *   { column: 'due', kind: 'date', op: 'isBefore', value: { mode: 'today' } },
+ *   { column: 'status', kind: 'select', op: 'isNot', value: 'Done' },
+ * ] })
+ * ```
+ */
+export function baseCondition(filter) {
+    return { kind: 'ext', type: 'fieldFilter', payload: { ...filter, kind: 'fieldFilter' } };
+}
+/** The base filter inside a predicate, or null when the predicate is something else. */
+export function baseFilterOf(expr) {
+    return expr?.kind === 'ext' && expr.type === 'fieldFilter' ? asFilter(expr.payload) : null;
+}
+let registered = false;
+/** Teach the expression language the base filter (once; `enableFields` calls it). */
+export function registerBaseCondition() {
+    if (registered)
+        return;
+    registered = true;
+    registerPredicateKind('fieldFilter', {
+        compile: (payload, ctx) => compileFieldFilter(asFilter(payload), ctx.getValue, linkNames),
+        describe: (payload, name) => describeFieldFilter(asFilter(payload), name),
+        columns: (payload) => fieldFilterColumns(asFilter(payload)),
+    });
+}
+/** A field's value in a record: computed for a formula, lookup, rollup or count. */
+export function fieldValue(column, row) {
+    const fn = column.def.fieldFn;
+    return fn ? fn(row) : row?.[column.field];
+}
+/** A field's value as its cell shows it, as text. */
+export function fieldText(column, row) {
+    const value = fieldValue(column, row);
+    const fmt = column.def.formatter;
+    if (fmt)
+        return String(fmt({ value, row, column: { id: column.id, columnDef: column.def } }) ?? '');
+    if (Array.isArray(value))
+        return value.join(', ');
+    return value == null ? '' : String(value);
+}

package/dist/fields/base-connect.d.ts

@@ -0,0 +1,82 @@
+import { type DbExecute, type SqlDialectName } from '../studio/introspect-db.js';
+import { type KitHandlerOptions } from '../sveltekit/transport.js';
+import { type SupabaseClientLike } from '../sources/supabase.js';
+import { type SupabaseRealtimeClientLike } from '../sources/realtime-supabase.js';
+import { type BaseTableSpec } from './base-schema.js';
+import type { BaseTable } from './base-tables.js';
+export type DatabaseOptions = {
+    /** Runs a query: `(sql, params) => rows`. With node-postgres: `async (sql, params) => (await pool.query(sql, params)).rows`. */
+    execute: DbExecute;
+    /** Default `'postgres'`. */
+    dialect?: SqlDialectName;
+    /** The tables to show, in tab order. Default: every table. */
+    tables?: string[];
+    /** Make text columns that repeat a few values single selects (default true). */
+    choices?: boolean;
+};
+/** The tables of a database, described as a base: plain JSON (what an endpoint sends). */
+export declare function describeDatabase(options: DatabaseOptions): Promise<BaseTableSpec[]>;
+/**
+ * A base on a SQL database, from its tables as they are.
+ *
+ * ```ts
+ * const tables = await baseFromDatabase({ execute: (sql, params) => db.query(sql, params).then((r) => r.rows) })
+ * ```
+ */
+export declare function baseFromDatabase(options: DatabaseOptions): Promise<BaseTable[]>;
+export type BaseEndpointOptions = DatabaseOptions & {
+    /** Who may read and write a table; see `createKitHandlers`' `authorize`. */
+    authorize?: (table: string) => KitHandlerOptions<Record<string, unknown>>['authorize'];
+    /** Each table's audit hook: `(table) => automations.audit(table)` runs server automations. */
+    audit?: (table: string) => KitHandlerOptions<Record<string, unknown>>['audit'];
+};
+/**
+ * The server half of `baseFromEndpoint`, as a SvelteKit route:
+ *
+ * ```ts
+ * // src/routes/api/base/+server.ts
+ * export const { GET, POST } = createBaseEndpoint({ execute: (sql, params) => pool.query(sql, params).then((r) => r.rows) })
+ * ```
+ *
+ * `GET` answers with the tables described as a base; `POST ?table=tasks`
+ * reads and writes that table. Only the tables it described are reachable.
+ */
+export declare function createBaseEndpoint(options: BaseEndpointOptions): {
+    GET(): Promise<Response>;
+    POST(event: {
+        request: Request;
+        locals?: Record<string, unknown>;
+    }): Promise<Response>;
+    /** Read the database's tables again (after a migration). */
+    refresh(): void;
+};
+/**
+ * A base on your server's `createBaseEndpoint`.
+ *
+ * ```svelte
+ * {#await baseFromEndpoint('/api/base') then tables}<SvBase {tables} editable />{/await}
+ * ```
+ */
+export declare function baseFromEndpoint(url: string, options?: {
+    fetch?: typeof fetch;
+}): Promise<BaseTable[]>;
+export type SupabaseBaseOptions = {
+    client: SupabaseClientLike & SupabaseRealtimeClientLike;
+    /** The project URL and anon key, for reading the tables' columns. */
+    url: string;
+    key: string;
+    /** The tables to show, in tab order. Default: every table the key can read. */
+    tables?: string[];
+    /** Hear other people's changes through Supabase Realtime (default true). */
+    realtime?: boolean;
+    choices?: boolean;
+    fetch?: typeof fetch;
+};
+/**
+ * A base on a Supabase project.
+ *
+ * ```ts
+ * const tables = await baseFromSupabase({ client: supabase, url: PUBLIC_SUPABASE_URL, key: PUBLIC_SUPABASE_ANON_KEY })
+ * ```
+ */
+export declare function baseFromSupabase(options: SupabaseBaseOptions): Promise<BaseTable[]>;