@svgrid/enterprise 3.1.8 → 3.1.9

package/dist/fields/base-sync.js

@@ -0,0 +1,499 @@
+import { colId, rowIdOf, syncInverse } from './base-tables.js';
+const isJunction = (l) => 'through' in l;
+const ids = (v) => (Array.isArray(v) ? v.map(String) : v == null || v === '' ? [] : [String(v)]);
+const request = (endRow, filter = {}) => ({
+    startRow: 0,
+    endRow,
+    pageIndex: 0,
+    pageSize: endRow,
+    sortModel: [],
+    filterModel: filter,
+});
+/**
+ * A value as the page keeps it: a date column read as a JS Date (PGlite,
+ * node-postgres) becomes 'YYYY-MM-DD', or a full ISO time when it has one.
+ */
+function fromDb(v) {
+    if (v instanceof Date) {
+        const iso = v.toISOString();
+        return iso.endsWith('T00:00:00.000Z') ? iso.slice(0, 10) : iso;
+    }
+    return v;
+}
+/**
+ * A base table's source from any data source with the grid's contract
+ * (`createSupabaseDataSource`, `createSqlDataSource`, `createRestDataSource`,
+ * `createInMemoryDataSource`, or your own).
+ *
+ * ```ts
+ * source: baseSource(createSupabaseDataSource({ client, table: 'tasks', schema }), {
+ *   links: { project: { column: 'project_id' } },
+ *   realtime: (onChange) => createSupabaseRealtime({ client, table: 'tasks', onChange }).unsubscribe,
+ * })
+ * ```
+ */
+export function baseSource(ds, options = {}) {
+    const limit = options.limit ?? 10000;
+    const idField = options.idField ?? 'id';
+    const links = options.links ?? {};
+    const rename = options.columns ?? {};
+    const back = new Map(Object.entries(rename).map(([f, c]) => [c, f]));
+    const fks = new Map(Object.entries(links).filter((e) => !isJunction(e[1])));
+    const junctions = Object.entries(links).filter((e) => isJunction(e[1]));
+    const fkColumns = new Map([...fks].map(([field, l]) => [l.column, field]));
+    /** A row as the database has it, as the page keeps it (junction links aside). */
+    function toPage(r) {
+        const row = {};
+        for (const [k, v] of Object.entries(r ?? {})) {
+            const fk = fkColumns.get(k);
+            if (fk)
+                row[fk] = v == null ? [] : [String(v)];
+            else
+                row[back.get(k) ?? k] = fromDb(v);
+        }
+        row.id = String(r?.[idField] ?? row.id ?? '');
+        return row;
+    }
+    // Junction row ids by "from|to", to delete a pair.
+    const pairs = new Map();
+    const pairKey = (a, b) => `${a}|${b}`;
+    const src = {
+        limit,
+        links,
+        skip: new Set(options.skip ?? []),
+        toPage,
+        async load() {
+            const res = await ds.getRows(request(limit));
+            const out = res.rows.map((r) => toPage(r));
+            for (const [field, j] of junctions) {
+                const seen = new Map();
+                pairs.set(field, seen);
+                const jr = await j.through.getRows(request(limit * 20));
+                const byFrom = new Map();
+                for (const p of jr.rows) {
+                    const a = String(p[j.from]);
+                    const b = String(p[j.to]);
+                    seen.set(pairKey(a, b), String(p[j.idField ?? 'id']));
+                    const list = byFrom.get(a);
+                    if (list)
+                        list.push(b);
+                    else
+                        byFrom.set(a, [b]);
+                }
+                for (const row of out)
+                    row[field] = byFrom.get(String(row.id)) ?? [];
+            }
+            return out;
+        },
+        async insert(row) {
+            const { stored, later } = split(row);
+            const created = (await ds.createRow(stored));
+            const id = String(created?.[idField] ?? row.id);
+            for (const [field, to] of later)
+                await addPairs(field, id, to);
+            return { ...row, id };
+        },
+        async update(id, patch, before) {
+            const { stored, later } = split(patch);
+            if (Object.keys(stored).length)
+                await ds.updateRow(id, stored);
+            for (const [field, to] of later) {
+                const was = new Set(ids(before[field]));
+                const now = new Set(to);
+                await addPairs(field, id, to.filter((x) => !was.has(x)));
+                await dropPairs(field, id, [...was].filter((x) => !now.has(x)));
+            }
+        },
+        async remove(id, before) {
+            for (const [field] of junctions)
+                await dropPairs(field, id, ids(before[field]));
+            await ds.deleteRow(id);
+        },
+        ...(options.realtime
+            ? {
+                subscribe: (onChange) => {
+                    const stop = options.realtime(onChange);
+                    return typeof stop === 'function' ? stop : () => stop.unsubscribe();
+                },
+            }
+            : {}),
+    };
+    /** A record's fields as columns, and its junction links to write after it. */
+    function split(row) {
+        const stored = {};
+        const later = [];
+        for (const [k, v] of Object.entries(row)) {
+            const link = links[k];
+            if (link && isJunction(link))
+                later.push([k, ids(v)]);
+            else if (link) {
+                const first = ids(v)[0];
+                stored[link.column] = first == null ? null : linkedId(k, first);
+            }
+            else if (k === 'id') {
+                if (!options.serverIds)
+                    stored[idField] = v;
+            }
+            else
+                stored[rename[k] ?? k] = v;
+        }
+        return { stored, later };
+    }
+    // A linked record's database id. The writer sets `ids` and knows the table.
+    const linkedTable = new Map();
+    function linkedId(field, id) {
+        const table = linkedTable.get(field);
+        return table && src.ids ? src.ids.toServer(table, id) : id;
+    }
+    async function addPairs(field, from, to) {
+        const j = links[field];
+        const seen = pairs.get(field) ?? new Map();
+        pairs.set(field, seen);
+        for (const x of to) {
+            const b = linkedId(field, x);
+            const made = (await j.through.createRow({ [j.from]: from, [j.to]: b }));
+            seen.set(pairKey(from, b), String(made?.[j.idField ?? 'id'] ?? ''));
+        }
+    }
+    async function dropPairs(field, from, to) {
+        const j = links[field];
+        const seen = pairs.get(field);
+        for (const x of to) {
+            const b = linkedId(field, x);
+            const pid = seen?.get(pairKey(from, b));
+            if (!pid)
+                continue;
+            await j.through.deleteRow(pid);
+            seen.delete(pairKey(from, b));
+        }
+    }
+    // The writer tells the source which table each link field points at.
+    ;
+    src.linkTables = linkedTable;
+    return src;
+}
+// ---- The writer -------------------------------------------------------------
+/** Field types worked out in the page: never written. */
+const COMPUTED = new Set(['formula', 'lookup', 'rollup', 'count', 'button']);
+const clone = (r) => {
+    const out = {};
+    for (const [k, v] of Object.entries(r))
+        out[k] = Array.isArray(v) ? [...v] : v && typeof v === 'object' ? JSON.parse(JSON.stringify(v)) : v;
+    return out;
+};
+const same = (a, b) => {
+    if (a === b)
+        return true;
+    if ((a == null || a === '') && (b == null || b === ''))
+        return true;
+    if (Array.isArray(a) || Array.isArray(b) || (a && typeof a === 'object') || (b && typeof b === 'object'))
+        return JSON.stringify(a ?? []) === JSON.stringify(b ?? []);
+    return false;
+};
+/** Whether a link field is the one worked out from the other side (that side stores the pairs). */
+function derivedLink(tables, def) {
+    const inverse = def.fieldProps?.inverse;
+    if (!inverse)
+        return false;
+    const other = tables.find((t) => t.id === def.fieldProps?.table);
+    const otherDef = other?.columns.find((d) => colId(d) === inverse);
+    const otherField = otherDef ? String(otherDef.field ?? colId(otherDef)) : '';
+    return !!other?.source?.links?.[otherField];
+}
+/** The fields of a table its source writes. */
+function storedFields(tables, t) {
+    const src = t.source;
+    return t.columns
+        .filter((d) => d.field != null && !COMPUTED.has(d.fieldType) && !src.skip.has(String(d.field)))
+        .filter((d) => !(d.fieldType === 'link' && !src.links[String(d.field)] && derivedLink(tables, d)))
+        .map((d) => String(d.field));
+}
+export function createBaseSync(options) {
+    // What the database holds, per table, by the record's page id.
+    const synced = new Map();
+    // Page id <-> database id, per table, for records the database gave its own id.
+    const toServerIds = new Map();
+    const toLocalIds = new Map();
+    const pendingInsert = new Set();
+    const stops = [];
+    let queue = Promise.resolve();
+    let pending = 0;
+    // The last failed write: the status keeps saying so until a write goes through.
+    let failure = null;
+    let disposed = false;
+    const status = (s) => options.onStatus?.(s);
+    const ids = {
+        toServer: (table, id) => toServerIds.get(table)?.get(id) ?? id,
+        toLocal: (table, id) => toLocalIds.get(table)?.get(id) ?? id,
+    };
+    const key = (table, id) => `${table}:${id}`;
+    function wire(t) {
+        const src = t.source;
+        src.ids = ids;
+        const linkTables = src.linkTables;
+        if (linkTables)
+            for (const d of t.columns)
+                if (d.fieldType === 'link' && d.fieldProps?.table)
+                    linkTables.set(String(d.field), String(d.fieldProps.table));
+    }
+    /** Records read from a source, with database ids turned into page ids. */
+    async function read(t) {
+        const rows = await t.source.load();
+        const linkTo = new Map(t.columns.filter((d) => d.fieldType === 'link').map((d) => [String(d.field), String(d.fieldProps?.table ?? '')]));
+        return rows.map((r) => {
+            const row = { ...r, id: ids.toLocal(t.id, String(r.id)) };
+            for (const [field, table] of linkTo)
+                if (field in row && Array.isArray(row[field]))
+                    row[field] = row[field].map((x) => ids.toLocal(table, x));
+            return row;
+        });
+    }
+    /** Fill in the fields that link back to a table from its rows. */
+    function linkBack(list, tableId) {
+        let next = list;
+        const t = next.find((x) => x.id === tableId);
+        for (const d of t?.columns ?? [])
+            if (d.fieldType === 'link' && d.fieldProps?.inverse && t?.source?.links[String(d.field)])
+                next = syncInverse(next, tableId, colId(d));
+        return next;
+    }
+    /** Load every table that has a source, then fill in the fields that link back. */
+    async function load() {
+        const list = options.getTables() ?? [];
+        const withSource = list.filter((t) => t.source);
+        if (!withSource.length)
+            return;
+        status({ state: 'loading' });
+        for (const t of withSource)
+            wire(t);
+        const loaded = new Map();
+        for (const t of withSource) {
+            try {
+                const rows = await read(t);
+                loaded.set(t.id, rows);
+                if (rows.length >= t.source.limit)
+                    status({ state: 'limited', table: t.name, limit: t.source.limit });
+            }
+            catch (e) {
+                failure = report(t, 'load', e);
+            }
+        }
+        if (disposed)
+            return;
+        let next = (options.getTables() ?? []).map((t) => (loaded.has(t.id) ? { ...t, data: loaded.get(t.id) } : t));
+        for (const t of withSource)
+            next = linkBack(next, t.id);
+        for (const t of next)
+            if (loaded.has(t.id))
+                remember(next, t);
+        options.apply(next);
+        for (const t of withSource) {
+            const stop = t.source.subscribe?.(() => refresh(t.id));
+            if (stop)
+                stops.push(stop);
+        }
+        if (pending === 0)
+            status(failure ?? { state: 'idle' });
+    }
+    function remember(list, t) {
+        const fields = storedFields(list, t);
+        const map = new Map();
+        for (const r of t.data)
+            if (r)
+                map.set(rowIdOf(t, r), pick(r, fields));
+        synced.set(t.id, map);
+    }
+    const pick = (r, fields) => {
+        const out = {};
+        for (const f of fields)
+            if (f in r)
+                out[f] = Array.isArray(r[f]) ? [...r[f]] : r[f] && typeof r[f] === 'object' ? clone({ v: r[f] }).v : r[f];
+        return out;
+    };
+    /** Compare the tables with what the database holds, and queue what differs. */
+    function push(list) {
+        if (!list || disposed)
+            return;
+        for (const t of list) {
+            const before = synced.get(t.id);
+            if (!t.source || !before)
+                continue;
+            const fields = storedFields(list, t);
+            const seen = new Set();
+            for (const r of t.data) {
+                if (!r)
+                    continue;
+                const id = rowIdOf(t, r);
+                seen.add(id);
+                const was = before.get(id);
+                if (!was) {
+                    if (pendingInsert.has(key(t.id, id)))
+                        continue;
+                    const row = pick(r, fields);
+                    before.set(id, row);
+                    pendingInsert.add(key(t.id, id));
+                    enqueue(t, 'insert', id, async () => {
+                        const stored = await t.source.insert({ ...row, id });
+                        const dbId = String(stored.id ?? id);
+                        if (dbId !== id) {
+                            const out = toServerIds.get(t.id) ?? new Map();
+                            out.set(id, dbId);
+                            toServerIds.set(t.id, out);
+                            const inn = toLocalIds.get(t.id) ?? new Map();
+                            inn.set(dbId, id);
+                            toLocalIds.set(t.id, inn);
+                        }
+                        pendingInsert.delete(key(t.id, id));
+                    }, () => {
+                        pendingInsert.delete(key(t.id, id));
+                        before.delete(id);
+                        undo(t.id, (rows) => rows.filter((x) => x && rowIdOf(t, x) !== id));
+                    });
+                    continue;
+                }
+                const patch = {};
+                for (const f of fields)
+                    if (!same(r[f], was[f]))
+                        patch[f] = Array.isArray(r[f]) ? [...r[f]] : r[f];
+                if (!Object.keys(patch).length)
+                    continue;
+                const prev = { ...was };
+                Object.assign(was, pick(patch, Object.keys(patch)));
+                enqueue(t, 'update', id, () => t.source.update(ids.toServer(t.id, id), patch, prev), () => {
+                    Object.assign(was, prev);
+                    undo(t.id, (rows) => rows.map((x) => (x && rowIdOf(t, x) === id ? { ...x, ...pick(prev, Object.keys(patch)) } : x)));
+                });
+            }
+            for (const [id, was] of [...before]) {
+                if (seen.has(id))
+                    continue;
+                before.delete(id);
+                enqueue(t, 'delete', id, () => t.source.remove(ids.toServer(t.id, id), was), () => {
+                    before.set(id, was);
+                    undo(t.id, (rows) => [...rows, { ...was, id }]);
+                });
+            }
+        }
+    }
+    function enqueue(t, action, _id, run, rollback) {
+        pending += 1;
+        status({ state: 'saving', pending });
+        queue = queue.then(async () => {
+            if (disposed)
+                return;
+            try {
+                await run();
+                failure = null;
+            }
+            catch (e) {
+                rollback();
+                failure = report(t, action, e);
+            }
+            finally {
+                pending -= 1;
+                if (pending === 0 && !disposed)
+                    status(failure ?? { state: 'idle' });
+                else if (!disposed)
+                    status({ state: 'saving', pending });
+            }
+        });
+    }
+    function report(t, action, e) {
+        const message = e instanceof Error ? e.message : String(e);
+        const s = { state: 'error', message, table: t.name };
+        status(s);
+        options.onError?.({ table: t.name, action, message });
+        return s;
+    }
+    /** Put a table's rows back as the database has them, without writing. */
+    function undo(tableId, change) {
+        const list = options.getTables();
+        if (!list)
+            return;
+        let next = list.map((t) => (t.id === tableId ? { ...t, data: change(t.data) } : t));
+        next = linkBack(next, tableId);
+        options.apply(next);
+    }
+    // Changes made elsewhere: read the table again and take what moved.
+    const timers = new Map();
+    function refresh(tableId) {
+        clearTimeout(timers.get(tableId));
+        timers.set(tableId, setTimeout(() => void reload(tableId), 120));
+    }
+    async function reload(tableId) {
+        const t0 = options.getTables()?.find((t) => t.id === tableId);
+        if (!t0?.source || disposed)
+            return;
+        // Our own writes first: what they changed is already in the page.
+        await queue;
+        let rows;
+        try {
+            rows = await read(t0);
+        }
+        catch (e) {
+            report(t0, 'load', e);
+            return;
+        }
+        const list = options.getTables();
+        const t = list?.find((x) => x.id === tableId);
+        const before = synced.get(tableId);
+        if (!list || !t || !before || disposed)
+            return;
+        const fields = storedFields(list, t);
+        const fresh = new Map(rows.map((r) => [String(r.id), r]));
+        let changed = false;
+        const data = [];
+        for (const r of t.data) {
+            if (!r)
+                continue;
+            const id = rowIdOf(t, r);
+            const server = fresh.get(id);
+            if (!server) {
+                if (pendingInsert.has(key(tableId, id)))
+                    data.push(r);
+                else {
+                    before.delete(id);
+                    changed = true;
+                }
+                continue;
+            }
+            fresh.delete(id);
+            const moved = fields.filter((f) => f in server && !same(server[f], before.get(id)?.[f]));
+            if (moved.length) {
+                changed = true;
+                const next = { ...r };
+                for (const f of moved)
+                    next[f] = server[f];
+                before.set(id, { ...before.get(id), ...pick(server, moved) });
+                data.push(next);
+            }
+            else
+                data.push(r);
+        }
+        for (const [id, r] of fresh) {
+            changed = true;
+            before.set(id, pick(r, fields));
+            data.push(r);
+        }
+        if (!changed)
+            return;
+        let next = list.map((x) => (x.id === tableId ? { ...x, data } : x));
+        next = linkBack(next, tableId);
+        options.apply(next);
+    }
+    return {
+        load,
+        push,
+        /** Read a table again now (after a change you know of). */
+        refresh,
+        /** Resolves when every queued write has finished. */
+        settled: () => queue,
+        dispose() {
+            disposed = true;
+            for (const stop of stops)
+                stop();
+            for (const t of timers.values())
+                clearTimeout(t);
+        },
+    };
+}

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

@@ -0,0 +1,89 @@
+import type { BaseAutomation } from './automations.svelte.js';
+import type { BaseSource } from './base-sync.js';
+import type { FieldView } from './view-model.js';
+type Row = Record<string, unknown>;
+type Def = Record<string, any>;
+/** One table of a base. */
+export type BaseTable = {
+    /** Unique across the app: link fields name it in `fieldProps.table`. */
+    id: string;
+    name: string;
+    data: Row[];
+    /** Columns declared by field type (`fieldType`, `fieldProps`). */
+    columns: Def[];
+    views?: FieldView[];
+    /** The field that names a record. Default: the first column. */
+    primaryField?: string;
+    /** A record's id. Default: its `id` property. */
+    getRowId?: (row: Row) => string;
+    /**
+     * Where the records live: a database or an API (`baseSource`). The table
+     * loads from it and writes every change back.
+     */
+    source?: BaseSource;
+    /** What happens when records are added, changed or match a condition (the view bar's Automations). */
+    automations?: BaseAutomation[];
+    /** Grid props for this table only (they win over the ones on `<SvBase>`). */
+    props?: Record<string, unknown>;
+};
+export declare const colId: (d: Def) => string;
+export declare const rowIdOf: (t: BaseTable, r: Row) => string;
+export declare const primaryOf: (t: BaseTable) => string;
+/**
+ * The field that links back from `def`'s table, made when `def` points at
+ * another table of the base and has none: a link field in that table named
+ * after this one, many records per record. Both fields name each other.
+ */
+export declare function addInverse(tables: BaseTable[], tableId: string, fieldId: string): BaseTable[];
+/**
+ * Make the field that links back agree with `fieldId`'s values: a record of
+ * the other table lists the records that link to it. Ids it already lists
+ * keep their place, new ones go at the end. When the field back holds one
+ * record (`multiple: false`), it keeps the one that linked last, and the
+ * records it was linked from before let go of it, so both sides agree.
+ */
+export declare function syncInverse(tables: BaseTable[], tableId: string, fieldId: string): BaseTable[];
+/**
+ * What is wrong with the links of the tables as loaded: an `inverse` that
+ * names no link field, and two sides of a link that disagree. The base does
+ * not rewrite loaded data, so it reports instead (once per message, in the
+ * console; SvBase calls this when it mounts).
+ */
+export declare function checkLinks(tables: BaseTable[], warn?: (message: string) => void): string[];
+/** Every link field of a table brings its other side up to date (after records are added or deleted). */
+export declare function syncAllInverses(tables: BaseTable[], tableId: string): BaseTable[];
+/** Remove the field that links back from `def` (its column and its values). */
+export declare function dropInverse(tables: BaseTable[], def: Def | undefined): BaseTable[];
+/**
+ * A field of `tableId` changed from `prev` to its current column. A link that
+ * now points at another table loses the field back in the old one, its values
+ * (ids of the old table's records) and gets a field back in the new one; a
+ * link turned into another type loses the field back.
+ */
+export declare function fieldChanged(tables: BaseTable[], tableId: string, prev: Def | undefined, fieldId: string): BaseTable[];
+/** The lookups, rollups and counts of a table (or a grid's columns) that read its link field `link`. */
+export declare function linkReaders(t: {
+    columns: ReadonlyArray<Def>;
+}, link: Def): Def[];
+/**
+ * Link field `def` of `tableId` was deleted (it is gone from the columns
+ * already): the lookups, rollups and counts that read it go too, and so do
+ * its field back, with its values, and the ones that read that.
+ */
+export declare function removeLinkField(tables: BaseTable[], tableId: string, def: Def | undefined): BaseTable[];
+/**
+ * Delete a table, and every link field of another table that points at it
+ * (with its values), with the lookups, rollups and counts that read those.
+ */
+export declare function removeTable(tables: BaseTable[], tableId: string): BaseTable[];
+export { newRecordId } from './field-ops.js';
+/** A table name not used yet: "Table 2", "Table 3". */
+export declare function freeTableName(tables: ReadonlyArray<BaseTable>, base?: string): string;
+/** A new table as a base starts one: Name, Notes and Status, three empty records, a grid view. */
+export declare function blankTable(tables: ReadonlyArray<BaseTable>, name?: string): BaseTable;
+/**
+ * A copy of a table: its fields, records and views, under a new name. Its
+ * link fields point at the same records; addInverse gives each one a field
+ * back once the copy is in the base.
+ */
+export declare function copyTable(tables: ReadonlyArray<BaseTable>, source: BaseTable): BaseTable;