wizards 0.2.11 → 0.2.13

package/apps/runtime/dist/services/space-data.js

@@ -0,0 +1,361 @@
+import { TableColumnValueError, tableColumnsSchema, } from "@engenty-wizards/shared/engenty/data-tables";
+import { editCells, SPACE_DATA_LIMITS, } from "@engenty-wizards/shared/space-data";
+import { rowKey } from "@engenty-wizards/shared/store";
+import { and, asc, count, desc, eq, inArray } from "drizzle-orm";
+import { nanoid } from "nanoid";
+import { db, schema } from "../db/client.js";
+import { currentTenant } from "../tenants/tenant.js";
+import { projectWritable, requireWritableProject } from "./access.js";
+import { notFound, ServiceError } from "./errors.js";
+import { ownedProject } from "./projects.js";
+/** A wizard of the space, or null for the space's own. */
+async function ownerOf(projectId, wizardId) {
+    if (!wizardId) {
+        return null;
+    }
+    const w = await db.query.wizard.findFirst({
+        where: and(eq(schema.wizard.id, wizardId), eq(schema.wizard.projectId, projectId)),
+        columns: { id: true },
+    });
+    if (!w) {
+        throw new ServiceError("invalid", "Diesen Wizard gibt es im Space nicht.");
+    }
+    return w.id;
+}
+function cellError(err) {
+    if (err instanceof TableColumnValueError) {
+        throw new ServiceError("invalid", err.message, { column: err.columnId });
+    }
+    throw err;
+}
+function checkColumns(columns) {
+    const parsed = tableColumnsSchema.safeParse(columns);
+    if (!parsed.success) {
+        throw new ServiceError("invalid", parsed.error.issues[0]?.message ?? "Ungültige Spalten.");
+    }
+    return parsed.data;
+}
+export async function listSpaceData(userId, projectId) {
+    const project = await ownedProject(userId, projectId);
+    const [tables, rows, pages, wizards] = await Promise.all([
+        db.query.spaceTable.findMany({
+            where: eq(schema.spaceTable.projectId, project.id),
+            orderBy: [asc(schema.spaceTable.title)],
+            columns: { id: true, wizardId: true, list: true, title: true, updatedAt: true },
+        }),
+        db
+            .select({ tableId: schema.spaceTableRow.tableId, n: count() })
+            .from(schema.spaceTableRow)
+            .innerJoin(schema.spaceTable, eq(schema.spaceTable.id, schema.spaceTableRow.tableId))
+            .where(eq(schema.spaceTable.projectId, project.id))
+            .groupBy(schema.spaceTableRow.tableId),
+        db.query.spacePage.findMany({
+            where: eq(schema.spacePage.projectId, project.id),
+            orderBy: [asc(schema.spacePage.title)],
+            columns: { id: true, wizardId: true, title: true, updatedAt: true },
+        }),
+        db.query.wizard.findMany({
+            where: eq(schema.wizard.projectId, project.id),
+            orderBy: [desc(schema.wizard.updatedAt)],
+            columns: { id: true, title: true },
+        }),
+    ]);
+    return {
+        tables: tables.map((t) => ({
+            ...t,
+            rows: rows.find((r) => r.tableId === t.id)?.n ?? 0,
+            updatedAt: t.updatedAt.toISOString(),
+        })),
+        pages: pages.map((p) => ({ ...p, updatedAt: p.updatedAt.toISOString() })),
+        wizards,
+    };
+}
+// --- tables --------------------------------------------------------------------
+async function tableRow(tableId) {
+    const table = await db.query.spaceTable.findFirst({
+        where: and(eq(schema.spaceTable.id, tableId), eq(schema.spaceTable.tenantId, currentTenant())),
+    });
+    if (!table) {
+        throw notFound();
+    }
+    return table;
+}
+async function writableTable(tableId) {
+    const table = await tableRow(tableId);
+    await requireWritableProject(table.projectId);
+    return table;
+}
+async function touchTable(tableId) {
+    await db
+        .update(schema.spaceTable)
+        .set({ updatedAt: new Date() })
+        .where(eq(schema.spaceTable.id, tableId));
+}
+export async function createTable(userId, projectId, input) {
+    const project = await ownedProject(userId, projectId);
+    await requireWritableProject(project.id);
+    const [{ n }] = await db
+        .select({ n: count() })
+        .from(schema.spaceTable)
+        .where(eq(schema.spaceTable.projectId, project.id));
+    if (n >= SPACE_DATA_LIMITS.tables) {
+        throw new ServiceError("refused", `Ein Space hat höchstens ${SPACE_DATA_LIMITS.tables} Tabellen.`);
+    }
+    const columns = input.columns
+        ? checkColumns(input.columns)
+        : [{ id: "name", name: "Name", type: "text" }];
+    const id = nanoid(12);
+    await db.insert(schema.spaceTable).values({
+        id,
+        tenantId: currentTenant(),
+        projectId: project.id,
+        wizardId: await ownerOf(project.id, input.wizardId),
+        title: input.title.trim() || "Tabelle",
+        columns,
+    });
+    return { id };
+}
+export async function getTable(userId, tableId) {
+    const table = await tableRow(tableId);
+    const project = await ownedProject(userId, table.projectId);
+    const rows = await db.query.spaceTableRow.findMany({
+        where: eq(schema.spaceTableRow.tableId, table.id),
+        orderBy: [asc(schema.spaceTableRow.createdAt), asc(schema.spaceTableRow.id)],
+    });
+    return {
+        id: table.id,
+        projectId: table.projectId,
+        wizardId: table.wizardId,
+        list: table.list,
+        title: table.title,
+        columns: table.columns,
+        rows: rows.map((r) => ({ id: r.id, cells: r.cells, updatedAt: r.updatedAt.toISOString() })),
+        readOnly: !(await projectWritable(project)),
+    };
+}
+/**
+ * A new title, owner or columns. Rows keep their cells: a removed column's cells are dropped
+ * the next time the row changes, and are not shown before.
+ */
+export async function updateTable(_userId, tableId, patch) {
+    const table = await writableTable(tableId);
+    if (table.list && (patch.columns !== undefined || patch.wizardId !== undefined)) {
+        throw new ServiceError("refused", "Diese Tabelle gehört zu einer Liste des Wizards: ihre Spalten kommen aus dem Wizard.");
+    }
+    await db
+        .update(schema.spaceTable)
+        .set({
+        ...(patch.title !== undefined ? { title: patch.title.trim() || table.title } : {}),
+        ...(patch.wizardId !== undefined
+            ? { wizardId: await ownerOf(table.projectId, patch.wizardId) }
+            : {}),
+        ...(patch.columns !== undefined ? { columns: checkColumns(patch.columns) } : {}),
+        updatedAt: new Date(),
+    })
+        .where(eq(schema.spaceTable.id, table.id));
+}
+export async function deleteTable(_userId, tableId) {
+    const table = await writableTable(tableId);
+    await db.delete(schema.spaceTable).where(eq(schema.spaceTable.id, table.id));
+}
+/** The key a row of a shared list is matched on; tables made in the studio have none. */
+function keyOf(table, cells) {
+    return table.keyColumn
+        ? rowKey({ id: table.list ?? "", title: table.title, columns: table.columns, key: table.keyColumn }, cells)
+        : null;
+}
+/** A row of a shared list whose key another row has already is refused: runs match on it. */
+async function refuseClash(tableId, key, rowId) {
+    if (!key) {
+        return;
+    }
+    const other = await db.query.spaceTableRow.findFirst({
+        where: and(eq(schema.spaceTableRow.tableId, tableId), eq(schema.spaceTableRow.key, key)),
+        columns: { id: true },
+    });
+    if (other && other.id !== rowId) {
+        throw new ServiceError("invalid", "Diesen Eintrag gibt es schon.");
+    }
+}
+/** Adds a row; `cells` may leave columns empty, even required ones, to be filled later. */
+export async function addTableRow(_userId, tableId, cells = {}) {
+    const table = await writableTable(tableId);
+    const [{ n }] = await db
+        .select({ n: count() })
+        .from(schema.spaceTableRow)
+        .where(eq(schema.spaceTableRow.tableId, table.id));
+    if (n >= SPACE_DATA_LIMITS.rowsPerTable) {
+        throw new ServiceError("refused", `Eine Tabelle hat höchstens ${SPACE_DATA_LIMITS.rowsPerTable} Zeilen.`);
+    }
+    let value;
+    try {
+        value = editCells(table.columns, {}, cells);
+    }
+    catch (err) {
+        cellError(err);
+    }
+    const key = keyOf(table, value);
+    await refuseClash(table.id, key, null);
+    const row = { id: nanoid(14), tableId: table.id, key, cells: value, createdAt: new Date() };
+    await db.insert(schema.spaceTableRow).values(row);
+    await touchTable(table.id);
+    return { id: row.id, cells: value };
+}
+/** Changes the cells named in `cells`; the others stay. */
+export async function updateTableRow(_userId, tableId, rowId, cells) {
+    const table = await writableTable(tableId);
+    const row = await db.query.spaceTableRow.findFirst({
+        where: and(eq(schema.spaceTableRow.id, rowId), eq(schema.spaceTableRow.tableId, table.id)),
+    });
+    if (!row) {
+        throw notFound();
+    }
+    let value;
+    try {
+        value = editCells(table.columns, row.cells, cells);
+    }
+    catch (err) {
+        cellError(err);
+    }
+    const key = keyOf(table, value);
+    await refuseClash(table.id, key, row.id);
+    await db
+        .update(schema.spaceTableRow)
+        .set({ cells: value, key, updatedAt: new Date() })
+        .where(eq(schema.spaceTableRow.id, row.id));
+    await touchTable(table.id);
+    return { id: row.id, cells: value };
+}
+export async function deleteTableRows(_userId, tableId, rowIds) {
+    const table = await writableTable(tableId);
+    if (!rowIds.length) {
+        return;
+    }
+    await db
+        .delete(schema.spaceTableRow)
+        .where(and(eq(schema.spaceTableRow.tableId, table.id), inArray(schema.spaceTableRow.id, rowIds)));
+    await touchTable(table.id);
+}
+// --- pages ---------------------------------------------------------------------
+async function pageRow(pageId) {
+    const page = await db.query.spacePage.findFirst({
+        where: and(eq(schema.spacePage.id, pageId), eq(schema.spacePage.tenantId, currentTenant())),
+    });
+    if (!page) {
+        throw notFound();
+    }
+    return page;
+}
+function checkMarkdown(markdown) {
+    if (markdown.length > SPACE_DATA_LIMITS.pageChars) {
+        throw new ServiceError("refused", `Eine Seite hat höchstens ${SPACE_DATA_LIMITS.pageChars.toLocaleString("de")} Zeichen.`);
+    }
+    return markdown;
+}
+export async function createPage(userId, projectId, input) {
+    const project = await ownedProject(userId, projectId);
+    await requireWritableProject(project.id);
+    const [{ n }] = await db
+        .select({ n: count() })
+        .from(schema.spacePage)
+        .where(eq(schema.spacePage.projectId, project.id));
+    if (n >= SPACE_DATA_LIMITS.pages) {
+        throw new ServiceError("refused", `Ein Space hat höchstens ${SPACE_DATA_LIMITS.pages} Seiten.`);
+    }
+    const id = nanoid(12);
+    await db.insert(schema.spacePage).values({
+        id,
+        tenantId: currentTenant(),
+        projectId: project.id,
+        wizardId: await ownerOf(project.id, input.wizardId),
+        title: input.title.trim() || "Seite",
+        markdown: checkMarkdown(input.markdown ?? ""),
+    });
+    return { id };
+}
+export async function getPage(userId, pageId) {
+    const page = await pageRow(pageId);
+    const project = await ownedProject(userId, page.projectId);
+    return {
+        id: page.id,
+        projectId: page.projectId,
+        wizardId: page.wizardId,
+        title: page.title,
+        markdown: page.markdown,
+        updatedAt: page.updatedAt.toISOString(),
+        readOnly: !(await projectWritable(project)),
+    };
+}
+export async function updatePage(_userId, pageId, patch) {
+    const page = await pageRow(pageId);
+    await requireWritableProject(page.projectId);
+    await db
+        .update(schema.spacePage)
+        .set({
+        ...(patch.title !== undefined ? { title: patch.title.trim() || page.title } : {}),
+        ...(patch.wizardId !== undefined
+            ? { wizardId: await ownerOf(page.projectId, patch.wizardId) }
+            : {}),
+        ...(patch.markdown !== undefined ? { markdown: checkMarkdown(patch.markdown) } : {}),
+        updatedAt: new Date(),
+    })
+        .where(eq(schema.spacePage.id, page.id));
+}
+export async function deletePage(_userId, pageId) {
+    const page = await pageRow(pageId);
+    await requireWritableProject(page.projectId);
+    await db.delete(schema.spacePage).where(eq(schema.spacePage.id, page.id));
+}
+// --- what runs read and write --------------------------------------------------
+// A run writes the pages of its own wizard, on the runtime it runs on: a run on the server writes
+// the server's, also in a space a local install synced, which the studio there only shows. It
+// reads its wizard's pages and the space's own.
+/** The pages a run can read: its wizard's, then the space's own. */
+export async function runPages(projectId, wizardId) {
+    const pages = await db.query.spacePage.findMany({
+        where: eq(schema.spacePage.projectId, projectId),
+        columns: { id: true, wizardId: true, title: true, markdown: true, updatedAt: true },
+        orderBy: [asc(schema.spacePage.title)],
+    });
+    return pages
+        .filter((p) => p.wizardId === wizardId || p.wizardId === null)
+        .sort((a, b) => Number(b.wizardId === wizardId) - Number(a.wizardId === wizardId));
+}
+/** Writes a page of the run's wizard: a new one, or the one with this title, replaced or added to. */
+export async function writeRunPage(projectId, wizardId, input) {
+    const title = input.title.trim();
+    if (!title) {
+        throw new ServiceError("invalid", "A page needs a title.");
+    }
+    const existing = (await db.query.spacePage.findMany({
+        where: and(eq(schema.spacePage.projectId, projectId), eq(schema.spacePage.wizardId, wizardId)),
+    })).find((p) => p.title.toLowerCase() === title.toLowerCase());
+    const markdown = existing && input.append
+        ? `${existing.markdown.trimEnd()}\n\n${input.markdown.trim()}`
+        : input.markdown;
+    checkMarkdown(markdown);
+    if (existing) {
+        await db
+            .update(schema.spacePage)
+            .set({ markdown, updatedAt: new Date() })
+            .where(eq(schema.spacePage.id, existing.id));
+        return { id: existing.id, title: existing.title, chars: markdown.length, made: false };
+    }
+    const [{ n }] = await db
+        .select({ n: count() })
+        .from(schema.spacePage)
+        .where(eq(schema.spacePage.projectId, projectId));
+    if (n >= SPACE_DATA_LIMITS.pages) {
+        throw new ServiceError("refused", `A space keeps at most ${SPACE_DATA_LIMITS.pages} pages.`);
+    }
+    const id = nanoid(12);
+    await db.insert(schema.spacePage).values({
+        id,
+        tenantId: currentTenant(),
+        projectId,
+        wizardId,
+        title: title.slice(0, 200),
+        markdown,
+    });
+    return { id, title, chars: markdown.length, made: true };
+}

package/apps/runtime/dist/services/spaces.js

@@ -1,7 +1,9 @@
 import { createHash } from "node:crypto";
+import { tableColumnsSchema } from "@engenty-wizards/shared/engenty/data-tables";
 import { PROJECT_LIMITS } from "@engenty-wizards/shared/projects";
+import { SPACE_DATA_LIMITS } from "@engenty-wizards/shared/space-data";
 import { WORKSPACE_LIMITS } from "@engenty-wizards/shared/workspace";
-import { and, count, eq, inArray, sql } from "drizzle-orm";
+import { and, count, eq, inArray, isNull, notInArray, sql } from "drizzle-orm";
 import { nanoid } from "nanoid";
 import { z } from "zod";
 import { db, inTransaction, schema } from "../db/client.js";
@@ -406,3 +408,95 @@ export async function removeSyncedSpace(rawSpaceId) {
     await asSync(() => removeProject(spaceId));
     return { ok: true };
 }
+// --- the space's own tables and pages --------------------------------------------
+// What the admin made under Space → Daten on the install, not what a wizard keeps: those stay
+// where their runs write them. Sent as a whole, it replaces what came before.
+export const syncDataSchema = z.object({
+    tables: z
+        .array(z.object({
+        id: syncedId,
+        title: z.string().min(1).max(120),
+        columns: tableColumnsSchema,
+        rows: z
+            .array(z.object({ id: syncedId, cells: z.record(z.string(), z.unknown()) }))
+            .max(SPACE_DATA_LIMITS.rowsPerTable),
+    }))
+        .max(SPACE_DATA_LIMITS.tables),
+    pages: z
+        .array(z.object({
+        id: syncedId,
+        title: z.string().min(1).max(200),
+        markdown: z.string().max(SPACE_DATA_LIMITS.pageChars),
+    }))
+        .max(SPACE_DATA_LIMITS.pages),
+});
+/**
+ * Takes the space's own tables and pages a local install sent: those it no longer has go, the
+ * others are written under the ids they have there. The space must be here already: it comes
+ * with the first wizard.
+ */
+export async function syncSpaceData(rawSpaceId, input) {
+    const spaceId = syncedId.parse(rawSpaceId);
+    const project = await syncedProject(spaceId);
+    if (project?.origin !== "local") {
+        throw notFound();
+    }
+    const own = (table) => and(eq(table.projectId, spaceId), isNull(table.wizardId));
+    const tableIds = input.tables.map((t) => t.id);
+    const pageIds = input.pages.map((p) => p.id);
+    // An id this tenant uses for something else is not taken over.
+    const [tablesHere, pagesHere] = await Promise.all([
+        tableIds.length
+            ? db.query.spaceTable.findMany({
+                where: inArray(schema.spaceTable.id, tableIds),
+                columns: { id: true, projectId: true, wizardId: true },
+            })
+            : [],
+        pageIds.length
+            ? db.query.spacePage.findMany({
+                where: inArray(schema.spacePage.id, pageIds),
+                columns: { id: true, projectId: true, wizardId: true },
+            })
+            : [],
+    ]);
+    if ([...tablesHere, ...pagesHere].some((x) => x.projectId !== spaceId || x.wizardId !== null)) {
+        throw new ServiceError("refused", "Eine Kennung ist hier schon vergeben.", {
+            reason: "id_taken",
+        });
+    }
+    const now = new Date();
+    await inTransaction(async () => {
+        await db
+            .delete(schema.spaceTable)
+            .where(and(own(schema.spaceTable), tableIds.length ? notInArray(schema.spaceTable.id, tableIds) : undefined));
+        await db
+            .delete(schema.spacePage)
+            .where(and(own(schema.spacePage), pageIds.length ? notInArray(schema.spacePage.id, pageIds) : undefined));
+        for (const table of input.tables) {
+            const values = { title: table.title, columns: table.columns, updatedAt: now };
+            await db
+                .insert(schema.spaceTable)
+                .values({ id: table.id, tenantId: currentTenant(), projectId: spaceId, ...values })
+                .onConflictDoUpdate({ target: schema.spaceTable.id, set: values });
+            await db.delete(schema.spaceTableRow).where(eq(schema.spaceTableRow.tableId, table.id));
+            for (let i = 0; i < table.rows.length; i += 200) {
+                const batch = table.rows.slice(i, i + 200);
+                // The order they stand in there: one millisecond apart.
+                await db.insert(schema.spaceTableRow).values(batch.map((row, j) => ({
+                    id: row.id,
+                    tableId: table.id,
+                    cells: row.cells,
+                    createdAt: new Date(now.getTime() - table.rows.length + i + j),
+                })));
+            }
+        }
+        for (const page of input.pages) {
+            const values = { title: page.title, markdown: page.markdown, updatedAt: now };
+            await db
+                .insert(schema.spacePage)
+                .values({ id: page.id, tenantId: currentTenant(), projectId: spaceId, ...values })
+                .onConflictDoUpdate({ target: schema.spacePage.id, set: values });
+        }
+    });
+    return { tables: input.tables.length, pages: input.pages.length };
+}

package/apps/runtime/dist/store/errors.js

@@ -0,0 +1,3 @@
+/** A store refused: a list is full, a path is not one, a row is there already. */
+export class StoreError extends Error {
+}

package/apps/runtime/dist/store/index.js

@@ -6,8 +6,9 @@ import { db, schema } from "../db/client.js";
 import { env } from "../env.js";
 import { getBlob, putBlob } from "../files/blobs.js";
 import { seal, unseal } from "../secrets/crypto.js";
-export class StoreError extends Error {
-}
+import { StoreError } from "./errors.js";
+import { deleteSharedRows, saveSharedRows, sharedRows } from "./shared-lists.js";
+export { StoreError };
 /** The person a run belongs to: the signed-in admin, else the visitor of the shared link. */
 export function holderOf(run) {
     if (run.userId) {
@@ -33,9 +34,13 @@ const inList = (scope, list) => and(eq(schema.storeRow.wizardId, scope.wizardId)
 function toRow(r) {
     return { id: r.id, cells: r.cells, updatedAt: r.updatedAt.toISOString() };
 }
-export async function listRows(scope, list) {
+/** The rows of a list: the person's, or every run's where the list is shared. */
+export async function listRows(scope, def) {
+    if (def.shared) {
+        return sharedRows(scope.wizardId, def);
+    }
     const rows = await db.query.storeRow.findMany({
-        where: inList(scope, list),
+        where: inList(scope, def.id),
         orderBy: [asc(schema.storeRow.createdAt), asc(schema.storeRow.id)],
     });
     return rows.map(toRow);
@@ -46,6 +51,9 @@ export async function listRows(scope, list) {
  * A row with a bad value is refused as a whole (`TableColumnValueError` names the column).
  */
 export async function saveRows(scope, def, input) {
+    if (def.shared) {
+        return saveSharedRows(scope.wizardId, def, input);
+    }
     let added = 0;
     let updated = 0;
     const existing = await db.query.storeRow.findMany({ where: inList(scope, def.id) });
@@ -82,8 +90,11 @@ export async function saveRows(scope, def, input) {
     await touchStore(scope);
     return { added, updated };
 }
-/** Changes cells of one row (the person edited it). */
+/** Changes cells of one row (the person edited it). A shared list is never the person's. */
 export async function updateRow(scope, def, rowId, patch) {
+    if (def.shared) {
+        return false;
+    }
     const row = await db.query.storeRow.findFirst({
         where: and(inList(scope, def.id), eq(schema.storeRow.id, rowId)),
     });
@@ -108,6 +119,9 @@ export async function updateRow(scope, def, rowId, patch) {
 }
 /** Deletes rows by id, or by the value of the key column. */
 export async function deleteRows(scope, def, idsOrKeys) {
+    if (def.shared) {
+        return deleteSharedRows(scope.wizardId, def, idsOrKeys);
+    }
     if (!idsOrKeys.length) {
         return 0;
     }

package/apps/runtime/dist/store/shared-lists.js

@@ -0,0 +1,124 @@
+import { newCells, patchCells, rowKey, STORE_LIMITS, } from "@engenty-wizards/shared/store";
+import { and, asc, eq, inArray } from "drizzle-orm";
+import { nanoid } from "nanoid";
+import { db, schema } from "../db/client.js";
+import { StoreError } from "./errors.js";
+const same = (a, b) => JSON.stringify(a) === JSON.stringify(b);
+/** The table a shared list is kept in: made the first time, following the list as it changes. */
+export async function sharedTable(wizardId, def) {
+    const where = and(eq(schema.spaceTable.wizardId, wizardId), eq(schema.spaceTable.list, def.id));
+    const found = await db.query.spaceTable.findFirst({ where });
+    const shape = { title: def.title, columns: def.columns, keyColumn: def.key ?? null };
+    if (found) {
+        if (found.title !== shape.title ||
+            found.keyColumn !== shape.keyColumn ||
+            !same(found.columns, shape.columns)) {
+            await db
+                .update(schema.spaceTable)
+                .set({ ...shape, updatedAt: new Date() })
+                .where(eq(schema.spaceTable.id, found.id));
+            return { ...found, ...shape };
+        }
+        return found;
+    }
+    const wizard = await db.query.wizard.findFirst({
+        where: eq(schema.wizard.id, wizardId),
+        columns: { projectId: true, tenantId: true },
+    });
+    if (!wizard) {
+        throw new StoreError("The wizard is gone.");
+    }
+    // Two runs that start at once make it once.
+    await db
+        .insert(schema.spaceTable)
+        .values({ id: nanoid(12), ...wizard, wizardId, list: def.id, ...shape })
+        .onConflictDoNothing();
+    const made = await db.query.spaceTable.findFirst({ where });
+    if (!made) {
+        throw new StoreError(`List "${def.id}" could not be made.`);
+    }
+    return made;
+}
+async function touch(tableId) {
+    await db
+        .update(schema.spaceTable)
+        .set({ updatedAt: new Date() })
+        .where(eq(schema.spaceTable.id, tableId));
+}
+function toRow(r) {
+    return { id: r.id, cells: r.cells, updatedAt: r.updatedAt.toISOString() };
+}
+export async function sharedRows(wizardId, def) {
+    const table = await sharedTable(wizardId, def);
+    const rows = await db.query.spaceTableRow.findMany({
+        where: eq(schema.spaceTableRow.tableId, table.id),
+        orderBy: [asc(schema.spaceTableRow.createdAt), asc(schema.spaceTableRow.id)],
+    });
+    return rows.map(toRow);
+}
+/** As `saveRows` does for one person's list: a row with a known key updates that row. */
+export async function saveSharedRows(wizardId, def, input) {
+    const table = await sharedTable(wizardId, def);
+    const existing = await db.query.spaceTableRow.findMany({
+        where: eq(schema.spaceTableRow.tableId, table.id),
+    });
+    const byKey = new Map(existing.filter((r) => r.key).map((r) => [r.key, r]));
+    let count = existing.length;
+    // Rows stand in the order they came, also those saved in the same second.
+    const at = Date.now();
+    let added = 0;
+    let updated = 0;
+    for (const raw of input) {
+        const key = rowKey(def, raw);
+        const hit = key ? byKey.get(key) : undefined;
+        if (hit) {
+            const cells = patchCells(def, hit.cells, raw);
+            await db
+                .update(schema.spaceTableRow)
+                .set({ cells, updatedAt: new Date() })
+                .where(eq(schema.spaceTableRow.id, hit.id));
+            hit.cells = cells;
+            updated++;
+            continue;
+        }
+        const cells = newCells(def, raw);
+        if (Object.values(cells).every((v) => v === null)) {
+            continue;
+        }
+        if (count >= STORE_LIMITS.rowsPerList) {
+            throw new StoreError(`List "${def.id}" is full (${STORE_LIMITS.rowsPerList} rows).`);
+        }
+        const row = { id: nanoid(14), tableId: table.id, key, cells, createdAt: new Date(at + added) };
+        await db.insert(schema.spaceTableRow).values(row);
+        if (key) {
+            byKey.set(key, { ...row, updatedAt: new Date() });
+        }
+        count++;
+        added++;
+    }
+    if (added || updated) {
+        await touch(table.id);
+    }
+    return { added, updated };
+}
+/** Deletes rows by id, or by the value of the key column. */
+export async function deleteSharedRows(wizardId, def, idsOrKeys) {
+    if (!idsOrKeys.length) {
+        return 0;
+    }
+    const table = await sharedTable(wizardId, def);
+    const keys = idsOrKeys.map((k) => k.trim().toLowerCase());
+    const inTable = eq(schema.spaceTableRow.tableId, table.id);
+    const byId = await db
+        .delete(schema.spaceTableRow)
+        .where(and(inTable, inArray(schema.spaceTableRow.id, idsOrKeys)))
+        .returning({ id: schema.spaceTableRow.id });
+    const byKey = await db
+        .delete(schema.spaceTableRow)
+        .where(and(inTable, inArray(schema.spaceTableRow.key, keys)))
+        .returning({ id: schema.spaceTableRow.id });
+    if (byId.length + byKey.length) {
+        await touch(table.id);
+    }
+    return byId.length + byKey.length;
+}

package/apps/runtime/dist/tools/index.js

@@ -13,6 +13,7 @@ import { browserTools } from "./browser.js";
 import { connectorTools } from "./connector.js";
 import { mailTools } from "./mail.js";
 import { assertPublicUrl, safeFetch } from "./net-guard.js";
+import { pageTools } from "./pages.js";
 import { pluginTools, spaceContextOf } from "./plugin.js";
 import { projectTools } from "./project.js";
 import { clip, FileKeeper } from "./shared.js";
@@ -98,6 +99,9 @@ export async function buildStepTools(step, ctx, resolved, uploads) {
     Object.assign(tools, await connectorTools(step, ctx, files));
     Object.assign(tools, await pluginTools(step, ctx));
     Object.assign(tools, (await spaceContextOf(ctx)).tools);
+    if (allowed.has("pages")) {
+        Object.assign(tools, pageTools(ctx));
+    }
     const sandbox = sandboxCapabilities();
     if (allowed.has("sandbox") && sandbox) {
         const timeoutMs = (seconds) => Math.min((seconds ?? 120) * 1000, 600_000);