@svgrid/enterprise 3.1.8 → 3.1.9

package/dist/fields/base-connect.js

@@ -0,0 +1,271 @@
+import { introspectDatabase, listDatabaseTables } from '../studio/introspect-db.js';
+import { createSqlDataSource } from '../sveltekit/sql-source.js';
+import { createKitDataSource, createKitHandlers } from '../sveltekit/transport.js';
+import { createSupabaseDataSource } from '../sources/supabase.js';
+import { createSupabaseRealtime } from '../sources/realtime-supabase.js';
+import { introspectSupabaseTable, listSupabaseTables } from '../sources/introspect-supabase.js';
+import { applyBaseComments, baseSpecFromSchemas, baseTablesFromSpec, withInverses } from './base-schema.js';
+import { SQL_COMMENT_PREFIX } from './base-sql.js';
+const SQL_DIALECT = {
+    postgres: { placeholders: '$', ilike: true },
+    supabase: { placeholders: '$', ilike: true },
+    mysql: { quote: '`', placeholders: '?' },
+    sqlite: { placeholders: '?' },
+    mssql: { placeholders: '@' },
+};
+const quote = (dialect, name) => dialect === 'mysql' ? `\`${name.replace(/`/g, '``')}\`` : dialect === 'mssql' ? `[${name.replace(/]/g, ']]')}]` : `"${name.replace(/"/g, '""')}"`;
+const param = (dialect, i) => (dialect === 'postgres' || dialect === 'supabase' ? `$${i}` : dialect === 'mssql' ? `@p${i}` : '?');
+/** The values each text column repeats, most used first (at most 13 per column). */
+async function readValues(o, dialect, schemas) {
+    const out = {};
+    for (const s of schemas) {
+        out[s.name] = {};
+        for (const f of s.fields) {
+            if (f.type !== 'text' || f.primaryKey)
+                continue;
+            const c = quote(dialect, f.field);
+            const top = dialect === 'mssql' ? 'TOP 13 ' : '';
+            const limit = dialect === 'mssql' ? '' : ' LIMIT 13';
+            try {
+                const rows = await o.execute(`SELECT ${top}${c} AS v, COUNT(*) AS n FROM ${quote(dialect, s.name)} WHERE ${c} IS NOT NULL GROUP BY ${c} ORDER BY COUNT(*) DESC${limit}`, []);
+                out[s.name][f.field] = rows.map((r) => ({ value: String(r.v), count: Number(r.n) }));
+            }
+            catch {
+                // A column it cannot group (a long text type): no choices for it.
+            }
+        }
+    }
+    return out;
+}
+/** The svgrid: comments baseToSql left on the tables and columns (Postgres). */
+async function readComments(o, dialect) {
+    const out = { tables: new Map(), columns: new Map(), junctions: new Map() };
+    if (dialect !== 'postgres' && dialect !== 'supabase')
+        return out;
+    let rows = [];
+    try {
+        rows = await o.execute(`select c.relname as tbl, a.attname as col, d.description as text
+       from pg_description d
+       join pg_class c on c.oid = d.objoid
+       join pg_namespace n on n.oid = c.relnamespace
+       left join pg_attribute a on a.attrelid = c.oid and a.attnum = d.objsubid and d.objsubid > 0
+       where n.nspname = 'public' and d.description like 'svgrid:%'`, []);
+    }
+    catch {
+        return out;
+    }
+    for (const r of rows)
+        addComment(out, String(r.tbl), r.col == null ? null : String(r.col), String(r.text));
+    return out;
+}
+/** One svgrid: comment, on a table (`col` null) or a column. */
+function addComment(out, table, col, text) {
+    if (!text.startsWith(SQL_COMMENT_PREFIX))
+        return;
+    let value;
+    try {
+        // PostgREST adds notes after the comment, on lines of their own.
+        value = JSON.parse(text.slice(SQL_COMMENT_PREFIX.length).split('\n')[0]);
+    }
+    catch {
+        return;
+    }
+    if (col != null)
+        out.columns.set(`${table}.${col}`, value);
+    else if (value?.junction)
+        out.junctions.set(table, value.junction);
+    else if (value?.v === 1)
+        out.tables.set(table, value);
+}
+/** The svgrid: comments, as Supabase's API description (PostgREST's OpenAPI) shows them. */
+async function readSupabaseComments(o) {
+    const out = { tables: new Map(), columns: new Map(), junctions: new Map() };
+    try {
+        const res = await (o.fetch ?? globalThis.fetch)(`${o.url.replace(/\/+$/, '')}/rest/v1/`, {
+            headers: { apikey: o.key, Authorization: `Bearer ${o.key}`, Accept: 'application/json' },
+        });
+        if (!res.ok)
+            return out;
+        const spec = (await res.json());
+        const defs = spec?.definitions ?? spec?.components?.schemas ?? {};
+        for (const [table, def] of Object.entries(defs)) {
+            if (typeof def?.description === 'string')
+                addComment(out, table, null, def.description);
+            for (const [col, prop] of Object.entries(def?.properties ?? {})) {
+                if (typeof prop?.description === 'string')
+                    addComment(out, table, col, prop.description);
+            }
+        }
+    }
+    catch {
+        // No API description (blocked, or a key that cannot read it): the base from the columns.
+    }
+    return out;
+}
+/** A base saved with baseToSql: the fields, views and automations it had, its tabs in their order. */
+function withComments(specs, comments, given) {
+    const out = withInverses(applyBaseComments(specs, comments));
+    if (!given && out.every((s) => comments.tables.get(s.id)?.position != null))
+        out.sort((a, b) => comments.tables.get(a.id).position - comments.tables.get(b.id).position);
+    return out;
+}
+const hasComments = (c) => c.tables.size > 0 || c.columns.size > 0;
+/** Whether the database fills in a table's key: a numeric key, or one with a default. */
+async function makesKeys(o, dialect, s) {
+    const pk = s.fields.find((f) => f.primaryKey);
+    if (!pk)
+        return false;
+    if (pk.type === 'number')
+        return true;
+    if (dialect !== 'postgres' && dialect !== 'supabase' && dialect !== 'mysql')
+        return false;
+    try {
+        const rows = await o.execute(`SELECT column_default AS d FROM information_schema.columns WHERE table_name = ${param(dialect, 1)} AND column_name = ${param(dialect, 2)}`, [s.name, pk.field]);
+        return rows.some((r) => r.d != null && String(r.d) !== '');
+    }
+    catch {
+        return false;
+    }
+}
+async function readDatabase(o) {
+    const dialect = o.dialect ?? 'postgres';
+    const names = o.tables ?? (await listDatabaseTables(dialect, o.execute));
+    const list = [];
+    for (const table of names)
+        list.push(await introspectDatabase({ dialect, table, execute: o.execute }));
+    // A junction table the list leaves out still carries a link to many.
+    const values = o.choices === false ? {} : await readValues(o, dialect, list);
+    const keys = new Map();
+    for (const s of list)
+        keys.set(s.name, await makesKeys(o, dialect, s));
+    const comments = await readComments(o, dialect);
+    const kept = hasComments(comments);
+    let specs = baseSpecFromSchemas(list, { values, serverIds: (s) => keys.get(s.name) ?? false, order: o.tables ? 'given' : 'links', inverses: !kept });
+    if (kept)
+        specs = withComments(specs, comments, !!o.tables);
+    return { specs, schemas: new Map(list.map((s) => [s.name, s])) };
+}
+/** The tables of a database, described as a base: plain JSON (what an endpoint sends). */
+export async function describeDatabase(options) {
+    return (await readDatabase(options)).specs;
+}
+/**
+ * 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 async function baseFromDatabase(options) {
+    const dialect = options.dialect ?? 'postgres';
+    const { specs, schemas } = await readDatabase(options);
+    return baseTablesFromSpec(specs, (table) => createSqlDataSource({ schema: schemas.get(table), table, dialect: SQL_DIALECT[dialect], execute: options.execute }));
+}
+/**
+ * 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 function createBaseEndpoint(options) {
+    const dialect = options.dialect ?? 'postgres';
+    let read = null;
+    const load = () => (read ?? (read = readDatabase(options).catch((e) => {
+        read = null;
+        throw e;
+    })));
+    const handlers = new Map();
+    const json = (body, status = 200) => new Response(JSON.stringify(body), { status, headers: { 'content-type': 'application/json' } });
+    return {
+        async GET() {
+            return json((await load()).specs);
+        },
+        async POST(event) {
+            const { schemas } = await load();
+            const table = new URL(event.request.url).searchParams.get('table') ?? '';
+            const schema = schemas.get(table);
+            if (!schema)
+                return json({ error: `No table "${table}"` }, 404);
+            let h = handlers.get(table);
+            if (!h) {
+                h = createKitHandlers({
+                    schema,
+                    source: createSqlDataSource({ schema, table, dialect: SQL_DIALECT[dialect], execute: options.execute }),
+                    ...(options.authorize ? { authorize: options.authorize(table) } : {}),
+                    ...(options.audit ? { audit: options.audit(table) } : {}),
+                });
+                handlers.set(table, h);
+            }
+            return h.POST(event);
+        },
+        /** Read the database's tables again (after a migration). */
+        refresh() {
+            read = null;
+            handlers.clear();
+        },
+    };
+}
+/**
+ * A base on your server's `createBaseEndpoint`.
+ *
+ * ```svelte
+ * {#await baseFromEndpoint('/api/base') then tables}<SvBase {tables} editable />{/await}
+ * ```
+ */
+export async function baseFromEndpoint(url, options = {}) {
+    const doFetch = options.fetch ?? globalThis.fetch;
+    const res = await doFetch(url);
+    if (!res.ok)
+        throw new Error(`${url} answered ${res.status}`);
+    const specs = (await res.json());
+    const at = (table) => `${url}${url.includes('?') ? '&' : '?'}table=${encodeURIComponent(table)}`;
+    return baseTablesFromSpec(specs, (table) => createKitDataSource({ endpoint: at(table), ...(options.fetch ? { fetch: options.fetch } : {}) }));
+}
+/**
+ * A base on a Supabase project.
+ *
+ * ```ts
+ * const tables = await baseFromSupabase({ client: supabase, url: PUBLIC_SUPABASE_URL, key: PUBLIC_SUPABASE_ANON_KEY })
+ * ```
+ */
+export async function baseFromSupabase(options) {
+    const names = options.tables ?? (await listSupabaseTables(options.url, options.key, options.fetch));
+    const schemas = [];
+    for (const table of names) {
+        const s = await introspectSupabaseTable({ url: options.url, key: options.key, table, ...(options.fetch ? { fetch: options.fetch } : {}) });
+        if (s)
+            schemas.push(s);
+    }
+    const values = {};
+    if (options.choices !== false) {
+        for (const s of schemas) {
+            const text = s.fields.filter((f) => f.type === 'text' && !f.primaryKey).map((f) => f.field);
+            if (!text.length)
+                continue;
+            const { data } = (await options.client.from(s.name).select(text.join(',')).range(0, 999));
+            values[s.name] = {};
+            for (const f of text) {
+                const counts = new Map();
+                for (const r of data ?? [])
+                    if (r[f] != null && r[f] !== '')
+                        counts.set(String(r[f]), (counts.get(String(r[f])) ?? 0) + 1);
+                values[s.name][f] = [...counts].map(([value, count]) => ({ value, count })).sort((a, b) => b.count - a.count);
+            }
+        }
+    }
+    const byName = new Map(schemas.map((s) => [s.name, s]));
+    const comments = await readSupabaseComments(options);
+    const kept = hasComments(comments);
+    // Supabase makes the keys: its source inserts without the page's id.
+    let specs = baseSpecFromSchemas(schemas, { values, serverIds: () => true, order: options.tables ? 'given' : 'links', inverses: !kept });
+    if (kept)
+        specs = withComments(specs, comments, !!options.tables);
+    return baseTablesFromSpec(specs, (table) => createSupabaseDataSource({ client: options.client, table, schema: byName.get(table) }), (s) => options.realtime === false
+        ? {}
+        : { realtime: (onChange) => createSupabaseRealtime({ client: options.client, table: s.id, onChange }) });
+}

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

@@ -0,0 +1,104 @@
+/**
+ * Base tables from a database's own description: the `EntitySchema` that
+ * `introspectSupabaseTable`, `introspectDatabase` or `introspectDrizzle`
+ * read.
+ *
+ * Column types become field types, helped by the column's name (`email`,
+ * `phone`, `price`, `notes`, `rating`); an enum, or a text column that keeps
+ * repeating a handful of values, becomes a single select with colored
+ * options; a foreign key becomes a link to the table it names, with a field
+ * in that table that links back; a table that only pairs two others
+ * (`task_tags`) becomes a link to many records instead of a tab of its own.
+ * Each table gets views that fit its fields: a grid, a Kanban board by its
+ * first select, a calendar by its first date.
+ *
+ * The result is first a `BaseTableSpec`: plain JSON, so a server can send it
+ * to the page. `baseTablesFromSpec` then gives each table its source.
+ */
+import type { ServerDataSource } from '@svgrid/grid';
+import type { EntitySchema } from '../schema.js';
+import { type BaseTable } from './base-tables.js';
+import { type BaseSourceOptions, type ForeignKeyLink } from './base-sync.js';
+import type { BaseJunctionComment, BaseTableComment } from './base-sql.js';
+type Def = Record<string, any>;
+/** How a link field is kept, by table name rather than by source: JSON-safe. */
+export type BaseLinkSpec = {
+    column: string;
+} | {
+    through: string;
+    from: string;
+    to: string;
+    idField?: string;
+};
+/** A base table as plain data: what `describeDatabase` reads and an endpoint sends. */
+export type BaseTableSpec = Omit<BaseTable, 'source' | 'data'> & {
+    /** How its link fields are stored. */
+    links?: Record<string, BaseLinkSpec>;
+    /** The record's key column. */
+    idField?: string;
+    /** The database makes the key of a new record. */
+    serverIds?: boolean;
+    /** Column names that differ from field names: `{ fixedOn: 'fixed_on' }`. */
+    rename?: Record<string, string>;
+};
+/** Values a text column holds, most used first, for turning it into a select. */
+export type ColumnValues = Record<string, Record<string, Array<{
+    value: string;
+    count: number;
+}>>>;
+/** One table's fields, its primary field and how its foreign keys are stored. */
+export declare function baseFieldsFromSchema(entity: EntitySchema): {
+    columns: Def[];
+    primaryField: string;
+    idField: string;
+    links: Record<string, ForeignKeyLink>;
+};
+export type DescribeOptions = {
+    /** Values of text columns, to make the ones that repeat a few values single selects. */
+    values?: ColumnValues;
+    /** The database makes the key of each table's new records (by table). */
+    serverIds?: (table: EntitySchema) => boolean;
+    /** Add a Kanban and a calendar view where the fields allow (default true). */
+    views?: boolean;
+    /** Add the field that links back for each link (default true; false when the database says which they are). */
+    inverses?: boolean;
+    /** 'links': the tables that link to the most others first (when nobody chose an order). */
+    order?: 'given' | 'links';
+};
+/**
+ * Base tables as plain data from database descriptions: fields, links (a
+ * junction table becomes a link to many), choices, the fields that link
+ * back, and views.
+ */
+export declare function baseSpecFromSchemas(entities: ReadonlyArray<EntitySchema | null | undefined>, options?: DescribeOptions): BaseTableSpec[];
+/** Every link gets the field that links back in the other table, unless it has one. */
+export declare function withInverses(specs: BaseTableSpec[]): BaseTableSpec[];
+/** What a database's svgrid: comments say (see baseToSql), by SQL table and column. */
+export type BaseComments = {
+    tables: Map<string, BaseTableComment>;
+    columns: Map<string, Def>;
+    junctions: Map<string, BaseJunctionComment['junction']>;
+};
+/**
+ * Lay what the comments keep over the base read from the columns: each
+ * field as it was (its type, options, format, name), the fields with no
+ * column (formulas, rollups, buttons, the fields that link back), a link to
+ * many under its own name, and the table's name, views and automations.
+ */
+export declare function applyBaseComments(specs: BaseTableSpec[], comments: BaseComments): BaseTableSpec[];
+/**
+ * Base tables from their specs: each gets a source from `sourceFor(table)`
+ * (also called for a junction table, by its name).
+ */
+export declare function baseTablesFromSpec(specs: ReadonlyArray<BaseTableSpec>, sourceFor: (table: string, spec?: BaseTableSpec) => ServerDataSource<any>, options?: (spec: BaseTableSpec) => Omit<BaseSourceOptions, 'links' | 'idField' | 'serverIds'>): BaseTable[];
+/**
+ * Base tables for a set of database tables, each on its own source, with a
+ * field that links back for every foreign key between them.
+ *
+ * ```ts
+ * const schemas = await Promise.all(['projects', 'tasks'].map((table) => introspectSupabaseTable({ url, key, table })))
+ * tables = baseTablesFromSchemas(schemas, (s) => createSupabaseDataSource({ client, table: s.name, schema: s }))
+ * ```
+ */
+export declare function baseTablesFromSchemas(entities: ReadonlyArray<EntitySchema | null | undefined>, sourceFor: (entity: EntitySchema) => ServerDataSource<any>, options?: (entity: EntitySchema) => Omit<BaseSourceOptions, 'links' | 'idField'>): BaseTable[];
+export {};

package/dist/fields/base-schema.js

@@ -0,0 +1,266 @@
+import { addInverse, colId } from './base-tables.js';
+import { baseSource } from './base-sync.js';
+import { BRIGHT } from './palette.js';
+const title = (s) => s.replace(/[_-]+/g, ' ').replace(/([a-z])([A-Z])/g, '$1 $2').trim().replace(/^\w/, (c) => c.toUpperCase());
+/** `project_id` -> `project`: the link field's name for a foreign key column. */
+const linkName = (column) => column.replace(/_?id$/i, '') || column;
+const MONEY = /(^|_)(price|amount|cost|budget|revenue|salary|total|fee|value|spend|mrr|arr)($|_)/i;
+const LONG = /(^|_)(notes?|description|body|comment|comments|summary|details|bio|content|message)($|_)/i;
+function fieldOf(f) {
+    const header = f.label ?? title(f.field);
+    const base = { id: f.field, field: f.field, header };
+    const editor = f.input?.editorType;
+    switch (f.type) {
+        case 'number':
+            if (editor === 'rating')
+                return { ...base, fieldType: 'rating', fieldProps: { max: 5 } };
+            if (MONEY.test(f.field))
+                return { ...base, fieldType: 'number', fieldProps: { format: 'currency', symbol: '$', precision: 0, summary: 'sum' } };
+            return { ...base, fieldType: 'number' };
+        case 'boolean':
+            return { ...base, fieldType: 'checkbox' };
+        case 'date':
+        case 'dateString':
+            return { ...base, fieldType: 'date', fieldProps: { dateFormat: 'friendly' } };
+        case 'datetime':
+            return { ...base, fieldType: 'date', fieldProps: { dateFormat: 'friendly', time: true } };
+        case 'enum':
+            return { ...base, fieldType: 'singleSelect', fieldProps: { options: (f.options ?? []).map((o, i) => ({ value: String(o.value), color: o.color ?? BRIGHT[i % BRIGHT.length].value })) } };
+        case 'json':
+            return { ...base, fieldType: 'longText' };
+        default:
+            if (f.format === 'email')
+                return { ...base, fieldType: 'email' };
+            if (f.format === 'url')
+                return { ...base, fieldType: 'url' };
+            if (editor === 'phone')
+                return { ...base, fieldType: 'phone' };
+            if (LONG.test(f.field))
+                return { ...base, fieldType: 'longText' };
+            return { ...base, fieldType: 'text' };
+    }
+}
+/** A width that shows a value of the type whole: a friendly date, an amount, an address. */
+function widthFor(d) {
+    switch (d.fieldType) {
+        case 'date':
+            return d.fieldProps?.time ? 210 : 170;
+        case 'longText':
+            return 240;
+        case 'email':
+        case 'url':
+            return 200;
+        case 'link':
+            return 180;
+        case 'checkbox':
+            return 90;
+        case 'rating':
+            return 120;
+        case 'number':
+            return Math.max(110, String(d.header).length * 9 + 40);
+        default:
+            return Math.max(130, Math.min(200, String(d.header).length * 9 + 60));
+    }
+}
+const PRIMARY = /^(name|title|subject|label|full_?name|display_?name|summary|headline)$/i;
+/** One table's fields, its primary field and how its foreign keys are stored. */
+export function baseFieldsFromSchema(entity) {
+    const idField = entity.idField ?? entity.fields.find((f) => f.primaryKey)?.field ?? 'id';
+    const columns = [];
+    const links = {};
+    for (const f of entity.fields) {
+        if (f.field === idField)
+            continue;
+        if (f.type === 'relation' && f.relation) {
+            const column = f.relation.foreignKey ?? f.field;
+            const name = linkName(f.field);
+            links[name] = { column };
+            columns.push({ id: name, field: name, header: f.label ? f.label.replace(/\s*id$/i, '') : title(name), fieldType: 'link', fieldProps: { table: f.relation.entity, multiple: false } });
+        }
+        else
+            columns.push(fieldOf(f));
+    }
+    const primary = columns.find((d) => PRIMARY.test(String(d.field))) ?? columns.find((d) => d.fieldType === 'text') ?? columns[0];
+    // The primary field leads.
+    if (primary && columns[0] !== primary)
+        columns.splice(0, 0, ...columns.splice(columns.indexOf(primary), 1));
+    for (const d of columns)
+        d.width ?? (d.width = d === primary ? 220 : widthFor(d));
+    return { columns, primaryField: primary ? String(primary.field) : idField, idField, links };
+}
+/** A table that only pairs two others: its key, two foreign keys, and at most a timestamp. */
+function isJunction(e) {
+    const rest = e.fields.filter((f) => !f.primaryKey && !/^(created|updated)_?(at|on)$/i.test(f.field));
+    const rels = rest.filter((f) => f.type === 'relation' && f.relation);
+    return rest.length === 2 && rels.length === 2 ? { from: rels[0], to: rels[1] } : null;
+}
+/** Whether a column's values read as a choice: a few values, each used more than once. */
+function asChoices(values) {
+    if (!values?.length || values.length > 12)
+        return null;
+    const used = values.reduce((n, v) => n + v.count, 0);
+    if (used < values.length * 2 || values.some((v) => v.value.length > 40))
+        return null;
+    return values.map((v) => v.value);
+}
+/**
+ * Base tables as plain data from database descriptions: fields, links (a
+ * junction table becomes a link to many), choices, the fields that link
+ * back, and views.
+ */
+export function baseSpecFromSchemas(entities, options = {}) {
+    const all = entities.filter((e) => !!e);
+    const junctions = new Map(all.map((e) => [e.name, isJunction(e)]).filter((x) => !!x[1]));
+    const names = new Set(all.filter((e) => !junctions.has(e.name)).map((e) => e.name));
+    let specs = all
+        .filter((e) => !junctions.has(e.name))
+        .map((e) => {
+        const { columns, primaryField, idField, links } = baseFieldsFromSchema(e);
+        // A foreign key to a table outside the set stays a plain value.
+        let kept = columns.map((d) => (d.fieldType === 'link' && !names.has(d.fieldProps.table) ? { ...d, field: links[d.field].column, id: links[d.field].column, header: title(links[d.field].column), fieldType: 'text', fieldProps: undefined } : d));
+        // A text column that repeats a handful of values: a single select.
+        kept = kept.map((d) => {
+            const choices = d.fieldType === 'text' && d.field !== primaryField ? asChoices(options.values?.[e.name]?.[String(d.field)]) : null;
+            return choices ? { ...d, width: 140, fieldType: 'singleSelect', fieldProps: { options: choices.map((value, i) => ({ value, color: BRIGHT[i % BRIGHT.length].value })) } } : d;
+        });
+        const keptLinks = Object.fromEntries(Object.entries(links).filter(([field]) => kept.some((d) => d.field === field)));
+        return {
+            id: e.name,
+            name: e.label && e.label !== e.name ? e.label : title(e.name),
+            primaryField,
+            columns: kept,
+            idField,
+            serverIds: options.serverIds?.(e) ?? false,
+            links: keptLinks,
+        };
+    });
+    // A junction table: a link to many on its first table, through it.
+    for (const [jname, j] of junctions) {
+        const fromTable = j.from.relation.entity;
+        const toTable = j.to.relation.entity;
+        const owner = specs.find((s) => s.id === fromTable);
+        if (!owner || !names.has(toTable))
+            continue;
+        const field = owner.columns.some((d) => d.field === toTable) ? `${toTable}_links` : toTable;
+        const target = specs.find((s) => s.id === toTable);
+        owner.columns = [...owner.columns, { id: field, field, header: target?.name ?? title(toTable), width: 220, fieldType: 'link', fieldProps: { table: toTable, multiple: true } }];
+        owner.links = { ...owner.links, [field]: { through: jname, from: j.from.relation.foreignKey ?? j.from.field, to: j.to.relation.foreignKey ?? j.to.field } };
+    }
+    // Every link gets the field that links back in the other table.
+    if (options.inverses !== false)
+        specs = withInverses(specs);
+    if (options.views !== false)
+        specs = specs.map((s) => ({ ...s, views: s.views ?? viewsFor(s) }));
+    if (options.order === 'links') {
+        // The table that points at the most others leads: orders before customers.
+        const out = (s) => Object.keys(s.links ?? {}).length;
+        specs = specs.map((s, i) => [s, i]).sort((a, b) => out(b[0]) - out(a[0]) || a[1] - b[1]).map(([s]) => s);
+    }
+    return specs;
+}
+/** Every link gets the field that links back in the other table, unless it has one. */
+export function withInverses(specs) {
+    let tables = specs.map((x) => ({ ...x, data: [] }));
+    for (const t of [...tables])
+        for (const d of t.columns)
+            if (d.fieldType === 'link' && d.fieldProps?.table !== t.id && !d.fieldProps?.inverse)
+                tables = addInverse(tables, t.id, colId(d));
+    return tables.map(({ data: _data, ...rest }) => rest);
+}
+/**
+ * Lay what the comments keep over the base read from the columns: each
+ * field as it was (its type, options, format, name), the fields with no
+ * column (formulas, rollups, buttons, the fields that link back), a link to
+ * many under its own name, and the table's name, views and automations.
+ */
+export function applyBaseComments(specs, comments) {
+    return specs.map((s0) => {
+        const s = { ...s0, columns: [...s0.columns], links: { ...(s0.links ?? {}) }, rename: { ...(s0.rename ?? {}) } };
+        s.columns = s.columns.map((d) => {
+            const field = String(d.field);
+            const link = s.links[field];
+            if (link && 'through' in link) {
+                const j = comments.junctions.get(link.through);
+                if (!j)
+                    return d;
+                delete s.links[field];
+                s.links[j.field] = link;
+                return { ...d, id: j.field, field: j.field };
+            }
+            const sqlColumn = link ? link.column : field;
+            const def = comments.columns.get(`${s.id}.${sqlColumn}`);
+            if (!def)
+                return d;
+            const name = String(def.field);
+            if (link) {
+                delete s.links[field];
+                s.links[name] = { column: sqlColumn };
+            }
+            else if (name !== sqlColumn)
+                s.rename[name] = sqlColumn;
+            return { ...def, id: name, field: name };
+        });
+        const c = comments.tables.get(s.id);
+        if (!c)
+            return s;
+        // Fields with no column, and a link to many as it was defined.
+        for (const e of c.extra) {
+            const at = s.columns.findIndex((d) => String(d.field) === String(e.field));
+            if (at >= 0)
+                s.columns[at] = { ...e, id: e.field };
+            else
+                s.columns.push({ ...e, id: e.field });
+        }
+        const order = new Map(c.order.map((f, i) => [f, i]));
+        s.columns.sort((a, b) => (order.get(String(a.field)) ?? 999) - (order.get(String(b.field)) ?? 999));
+        return {
+            ...s,
+            name: c.name,
+            ...(c.primaryField ? { primaryField: c.primaryField } : {}),
+            ...(c.views ? { views: c.views } : {}),
+            ...(c.automations ? { automations: c.automations } : {}),
+        };
+    });
+}
+/** A grid colored by the first select, a board by it, a calendar by the first date. */
+function viewsFor(s) {
+    const select = s.columns.find((d) => d.fieldType === 'singleSelect');
+    const date = s.columns.find((d) => d.fieldType === 'date');
+    const views = [{ id: 'grid', name: `All ${s.name.toLowerCase()}`, type: 'grid', ...(select ? { color: { mode: 'field', field: String(select.field) } } : {}) }];
+    if (select)
+        views.push({ id: 'board', name: `By ${String(select.header).toLowerCase()}`, type: 'kanban', stackBy: String(select.field) });
+    if (date)
+        views.push({ id: 'calendar', name: `${date.header} calendar`, type: 'calendar', dateField: String(date.field), ...(select ? { color: { mode: 'field', field: String(select.field) } } : {}) });
+    return views;
+}
+/**
+ * Base tables from their specs: each gets a source from `sourceFor(table)`
+ * (also called for a junction table, by its name).
+ */
+export function baseTablesFromSpec(specs, sourceFor, options = () => ({})) {
+    return specs.map((s) => {
+        const { links = {}, idField, serverIds, rename, ...table } = s;
+        const resolved = {};
+        for (const [field, l] of Object.entries(links))
+            resolved[field] = 'through' in l ? { through: sourceFor(l.through), from: l.from, to: l.to, ...(l.idField ? { idField: l.idField } : {}) } : l;
+        return { ...table, data: [], source: baseSource(sourceFor(s.id, s), { ...options(s), links: resolved, idField, serverIds, ...(rename && Object.keys(rename).length ? { columns: rename } : {}) }) };
+    });
+}
+/**
+ * Base tables for a set of database tables, each on its own source, with a
+ * field that links back for every foreign key between them.
+ *
+ * ```ts
+ * const schemas = await Promise.all(['projects', 'tasks'].map((table) => introspectSupabaseTable({ url, key, table })))
+ * tables = baseTablesFromSchemas(schemas, (s) => createSupabaseDataSource({ client, table: s.name, schema: s }))
+ * ```
+ */
+export function baseTablesFromSchemas(entities, sourceFor, options = () => ({})) {
+    const list = entities.filter((e) => !!e);
+    const byName = new Map(list.map((e) => [e.name, e]));
+    const specs = baseSpecFromSchemas(list, { views: false, serverIds: (e) => !!options(e).serverIds });
+    return baseTablesFromSpec(specs.map((s) => ({ ...s, views: s.views ?? [{ id: 'grid', name: 'Grid view', type: 'grid' }] })), (table) => sourceFor(byName.get(table)), (s) => {
+        const { serverIds: _s, ...rest } = options(byName.get(s.id));
+        return rest;
+    });
+}