@protobase/server 0.23.3 → 0.23.4

package/dist/changes/capture-plan.js

@@ -1,5 +1,6 @@
 import { captureBody, captureFunctionSql, createTriggerSql, dropTriggerSql, isCaptured, outboxSql, quoteIdent, resourceTriggers, tableSql } from "./capture-sql.js";
 import { historyTableSql } from "../history/history-sql.js";
+import { noticesTableSql } from "../live/notices-sql.js";
 //#region src/changes/capture-plan.ts
 const sameTrigger = (found, wanted) => found.type === wanted.type && found.args.length === wanted.args.length && found.args.every((arg, index) => arg === wanted.args[index]);
 const tableOf = (state, model) => {
@@ -8,7 +9,7 @@ const tableOf = (state, model) => {
 	return table;
 };
 /**
-* Compares the database with the resources that declare events or history. Fails on what it cannot change safely: a
+* Compares the database with the resources that declare events, history or live updates. Fails on what it cannot change safely: a
 * missing table, two captured resources on one table, or a trigger of the same name that calls another function.
 */
 const capturePlan = (schema, models, state) => {
@@ -35,6 +36,7 @@ const capturePlan = (schema, models, state) => {
 	return {
 		setup: captured.length > 0 && (!state.outbox || !current),
 		history: models.some((model) => model.history) && !state.history,
+		notices: models.some((model) => model.live) && !state.notices,
 		create: create.map(({ model, trigger }) => ({
 			model,
 			trigger
@@ -54,12 +56,17 @@ const planSql = (schema, plan) => {
 			captureFunctionSql(schema)
 		] : [],
 		...plan.history ? [`create schema if not exists ${quoteIdent(schema)}`, historyTableSql(schema)] : [],
+		...plan.notices ? [`create schema if not exists ${quoteIdent(schema)}`, noticesTableSql(schema)] : [],
 		...plan.drop.map(({ name, tableSql }) => dropTriggerSql(name, tableSql)),
 		...plan.create.flatMap(({ model, trigger }) => [dropTriggerSql(trigger.name, tableSql(model)), createTriggerSql(schema, trigger, tableSql(model))])
 	];
 	return statements.length === 0 ? void 0 : `${statements.join(";\n\n")};`;
 };
 /** The resources whose changes would not be captured or kept as the config declares: what a server refuses to start with. */
-const uncaptured = (plan, models) => [...new Set([...plan.setup ? models.filter(isCaptured) : plan.create.map(({ model }) => model), ...plan.history ? models.filter((model) => model.history) : []].map((model) => model.name))];
+const uncaptured = (plan, models) => [...new Set([
+	...plan.setup ? models.filter(isCaptured) : plan.create.map(({ model }) => model),
+	...plan.history ? models.filter((model) => model.history) : [],
+	...plan.notices ? models.filter((model) => model.live) : []
+].map((model) => model.name))];
 //#endregion
 export { capturePlan, planSql, uncaptured };

package/dist/changes/capture-schema.d.ts

@@ -5,15 +5,15 @@ import { Db } from "@protobase/query";
 /** The command that writes what the config needs as a migration file of the project. */
 export declare const migrationCommand = "protobase migration";
 /**
- * The SQL that brings the database to the capture the resources' events and history need: the schema with the outbox
- * and `capture()`, the history table, and a trigger pair per resource with either, recreated when its fields changed;
- * triggers of resources without either any more are dropped. `undefined` when the database is current. Tables are
+ * The SQL that brings the database to the capture the resources' events, history and live updates need: the schema
+ * with the outbox and `capture()`, the history and notices tables, and a trigger pair per resource with any of them, recreated when its fields changed;
+ * triggers of resources without any of them any more are dropped. `undefined` when the database is current. Tables are
  * never dropped.
  */
 export declare const changesMigration: (db: Db, models: readonly ResourceModel[], options?: EventsOptions) => Promise<string | undefined>;
 /**
- * Refuses to go on while a resource's events or history would not be captured as declared: a missing or out-of-date
- * schema, history table or trigger. The server never changes the schema itself: the project's migrations do, before the
+ * Refuses to go on while a resource's events, history or live updates would not be captured as declared: a missing or
+ * out-of-date schema, history or notices table, or trigger. The server never changes the schema itself: the project's migrations do, before the
  * new version serves.
  */
 export declare const checkChanges: (db: Db, models: readonly ResourceModel[], options?: EventsOptions) => Promise<void>;

package/dist/changes/capture-schema.js

@@ -26,6 +26,7 @@ const readCaptureState = async (db, schema, models) => {
 	return {
 		outbox: await exists("outbox"),
 		history: await exists("history"),
+		notices: await exists("notices"),
 		...capture && { capture },
 		triggers: triggers.map((trigger) => ({
 			...trigger,
@@ -42,9 +43,9 @@ const plan = async (db, models, options) => {
 	};
 };
 /**
-* The SQL that brings the database to the capture the resources' events and history need: the schema with the outbox
-* and `capture()`, the history table, and a trigger pair per resource with either, recreated when its fields changed;
-* triggers of resources without either any more are dropped. `undefined` when the database is current. Tables are
+* The SQL that brings the database to the capture the resources' events, history and live updates need: the schema
+* with the outbox and `capture()`, the history and notices tables, and a trigger pair per resource with any of them, recreated when its fields changed;
+* triggers of resources without any of them any more are dropped. `undefined` when the database is current. Tables are
 * never dropped.
 */
 const changesMigration = async (db, models, options) => {
@@ -52,8 +53,8 @@ const changesMigration = async (db, models, options) => {
 	return planSql(schema, found);
 };
 /**
-* Refuses to go on while a resource's events or history would not be captured as declared: a missing or out-of-date
-* schema, history table or trigger. The server never changes the schema itself: the project's migrations do, before the
+* Refuses to go on while a resource's events, history or live updates would not be captured as declared: a missing or
+* out-of-date schema, history or notices table, or trigger. The server never changes the schema itself: the project's migrations do, before the
 * new version serves.
 */
 const checkChanges = async (db, models, options) => {
@@ -61,7 +62,7 @@ const checkChanges = async (db, models, options) => {
 	const { plan: found } = await plan(db, models, options);
 	const missing = uncaptured(found, models);
 	if (missing.length === 0) return;
-	throw new Error(`The changes of ${missing.join(", ")} are not captured as their events or history need: their triggers, the history table or the changes schema are missing or out of date. Write the change as a migration with \`${migrationCommand}\`, apply it with the project's migrations, then start again.`);
+	throw new Error(`The changes of ${missing.join(", ")} are not captured as their events, history or live updates need: their triggers, the history or notices table or the changes schema are missing or out of date. Write the change as a migration with \`${migrationCommand}\`, apply it with the project's migrations, then start again.`);
 };
 //#endregion
 export { changesMigration, checkChanges, migrationCommand };

package/dist/changes/capture-sql.d.ts

@@ -1,5 +1,5 @@
 import { ResourceModel } from "@protobase/schema";
 //#region src/changes/capture-sql.d.ts
-/** Whether the triggers capture a resource's changes: for its events, its history, or both. */
+/** Whether the triggers capture a resource's changes: for its events, its history, its live updates, or several. */
 export declare const isCaptured: (model: ResourceModel) => boolean;
 //#endregion

package/dist/changes/capture-sql.js

@@ -16,8 +16,8 @@ const identifier = (name) => {
 };
 /** The table as SQL names it, qualified when the resource names a schema. */
 const tableSql = (model) => qualified(model.table);
-/** Whether the triggers capture a resource's changes: for its events, its history, or both. */
-const isCaptured = (model) => (model.events ?? []).length > 0 || model.history === true;
+/** Whether the triggers capture a resource's changes: for its events, its history, its live updates, or several. */
+const isCaptured = (model) => (model.events ?? []).length > 0 || model.history === true || model.live === true;
 /**
 * The outbox: one row per changed row, written in the writer's transaction. `transaction` is the writer's transaction
 * id; `database_role` the role that wrote; `dispatch_after` holds back a change that the process which wrote it is

package/dist/check-views.js

@@ -60,7 +60,7 @@ const textHintErrors = (view, model) => Object.entries(view.fields).flatMap(([na
 	const format = hints.format !== void 0 && textFormats.has(hints.format) ? [`format('${hints.format}') of "${name}" needs a text field, not ${field.type}`] : [];
 	return [...textHints.filter((hint) => hints[hint]).map((hint) => `${hint} "${name}" needs a text field, not ${field.type}`), ...format];
 });
-const linkErrors = (view, model, models, pages) => view.actions.flatMap(({ name, label, run }) => {
+const linkErrors = (view, model, models, pages, createPages) => view.actions.flatMap(({ name, label, run }) => {
 	if (run?.kind !== "link") return [];
 	const error = linkActionError(label, run);
 	if (error) return [`action "${name}": ${error}`];
@@ -69,7 +69,8 @@ const linkErrors = (view, model, models, pages) => view.actions.flatMap(({ name,
 	return "to" in run ? addressErrors(run.to, {
 		models,
 		pages,
-		source: model
+		source: model,
+		createPages
 	}).map((error) => `action "${name}": ${error}`) : [];
 });
 const aiActionErrors = (view, model) => view.actions.flatMap(({ name, run }) => {
@@ -151,6 +152,7 @@ const listOfErrors = (model, name, models) => {
 const checkViews = (registry, views, pages = [], fieldTypes = {}) => {
 	const models = Object.fromEntries(registry.entries.map((entry) => [entry.name, entry.model]));
 	const pageNames = new Set(pages);
+	const createPages = new Set(views.filter((view) => view.create).map((view) => view.resource));
 	const viewProblems = (view, model) => {
 		const related = [...layoutItems(view.layout).flatMap((item) => item.kind === "related" ? relatedErrors(item, view.resource, models).map((error) => `related "${item.title}": ${error}`) : []), ...relatedColumnsErrors(view, model, models)];
 		const photos = [
@@ -187,7 +189,7 @@ const checkViews = (registry, views, pages = [], fieldTypes = {}) => {
 			...boards,
 			...calendars,
 			...chart,
-			...linkErrors(view, model, models, pageNames),
+			...linkErrors(view, model, models, pageNames, createPages),
 			...aiActionErrors(view, model),
 			...inputErrors(view, models),
 			...createErrors(view, pageNames)

package/dist/create-admin.js

@@ -33,6 +33,9 @@ import { checkBottomBars, checkShell } from "./check-shell.js";
 import { checkOwnerFields } from "./check-owners.js";
 import { checkRoleLimits } from "./check-roles.js";
 import { checkViews } from "./check-views.js";
+import { liveRoutes } from "./live/live-route.js";
+import { tableFeed } from "./live/notice-feed.js";
+import { visibleNotices } from "./live/visible-notices.js";
 import { errorReportingSettings } from "./error-reporting/error-reporting-settings.js";
 import { createFilesRuntime } from "./files/runtime.js";
 import { fileRoutes } from "./files/routes.js";
@@ -96,7 +99,8 @@ const createAdmin = ({ resources: appResources, views: appViews = [], pages = []
 	checkOwnerFields(registry, auth);
 	checkPages(pageModels, {
 		models: Object.fromEntries(registry.entries.map((entry) => [entry.name, entry.model])),
-		actions: (resource) => new Set(viewModels.filter((view) => view.resource === resource).flatMap((view) => view.actions.map((action) => action.name)))
+		actions: (resource) => new Set(viewModels.filter((view) => view.resource === resource).flatMap((view) => view.actions.map((action) => action.name))),
+		createPages: new Set(viewModels.filter((view) => view.create).map((view) => view.resource))
 	});
 	const forms = createFormsRuntime({
 		registry,
@@ -248,6 +252,14 @@ const createAdmin = ({ resources: appResources, views: appViews = [], pages = []
 	app.route("/", batchRoute(deps, authenticate, meta));
 	app.route("/", fileRoutes(deps, authenticate));
 	if (forms) app.route(`${systemPath}/forms`, formRoutes(deps, forms));
+	if (appModels.some((model) => model.live)) {
+		const feed = tableFeed({
+			db,
+			schema: changes,
+			report: options.onUnhandledError ?? ((error) => console.error(error))
+		});
+		app.route(systemPath || "/", guarded((live) => void live.route("/", liveRoutes(feed, (session) => visibleNotices(deps, session))), withAnonymous(authenticate, options.roles)));
+	}
 	app.route(basePath, api);
 	app.route(`${deps.systemPath}/meta`, metaApp);
 	app.route(deps.systemPath || "/", system);

package/dist/live/live-route.js

@@ -0,0 +1,84 @@
+import { parseParams } from "../params.js";
+import { Hono } from "hono";
+import { z } from "zod";
+import { streamSSE } from "hono/streaming";
+//#region src/live/live-route.ts
+const params = z.object({ after: z.string().regex(/^\d+$/, "Use the cursor of an earlier event").optional() });
+/** Notices a reconnecting page catches up on at most; one that missed more reads everything again. */
+const replayLimit = 1e3;
+const heartbeatMs = 25e3;
+const later = (id, than) => BigInt(id) > BigInt(than);
+/**
+* `GET /live`: the changes of the live resources the caller may read, as they come, keys only. `visibleTo` says which
+* notices a caller hears of (`visibleNotices`).
+*/
+const liveRoutes = (feed, visibleTo) => {
+	const app = new Hono();
+	app.get("/live", async (c) => {
+		const { after } = parseParams(params, c.req.query());
+		const visible = await visibleTo(c.get("session"));
+		const changesOf = (notices) => notices.filter(visible).map(({ resource, key, operation }) => ({
+			resource,
+			key,
+			operation
+		}));
+		const queue = [];
+		let wake = () => {};
+		const held = [];
+		let deliver = (notices) => void held.push(...notices);
+		let heartbeat;
+		let stop = () => {};
+		const follow = async (stream) => {
+			stream.onAbort(() => wake());
+			const subscription = await feed.subscribe((notices) => deliver(notices));
+			stop = subscription.stop;
+			const caught = after === void 0 ? [] : await feed.replay(after, subscription.cursor, replayLimit);
+			let cursor = after !== void 0 && caught && later(after, subscription.cursor) ? after : subscription.cursor;
+			if (!caught) queue.push({
+				type: "resync",
+				cursor
+			});
+			else if (changesOf(caught).length > 0) queue.push({
+				type: "changes",
+				cursor,
+				changes: changesOf(caught)
+			});
+			else queue.push({
+				type: "current",
+				cursor
+			});
+			deliver = (notices) => {
+				const fresh = notices.filter((notice) => later(notice.id, cursor));
+				if (fresh.length === 0) return;
+				cursor = fresh.at(-1).id;
+				const changes = changesOf(fresh);
+				if (changes.length > 0) queue.push({
+					type: "changes",
+					cursor,
+					changes
+				});
+				wake();
+			};
+			deliver(held);
+			heartbeat = setInterval(() => {
+				queue.push({
+					type: "current",
+					cursor
+				});
+				wake();
+			}, heartbeatMs);
+			while (!stream.aborted) {
+				const event = queue.shift();
+				if (event) await stream.writeSSE({ data: JSON.stringify(event) });
+				else await new Promise((resolve) => wake = resolve);
+			}
+		};
+		return streamSSE(c, (stream) => follow(stream).finally(() => {
+			clearInterval(heartbeat);
+			stop();
+		}));
+	});
+	return app;
+};
+//#endregion
+export { liveRoutes };

package/dist/live/notice-feed.js

@@ -0,0 +1,61 @@
+import { lastNotice, noticeKept, noticesAfter } from "./notices-sql.js";
+//#region src/live/notice-feed.ts
+/** Notices read from a batch at most. */
+const batchSize = 1e3;
+const after = (id, than) => BigInt(id) > BigInt(than);
+/**
+* The notices table, read once every `intervalMs` by this process while at least one page listens, however many do:
+* the cost of open pages is one indexed query a second per process.
+*/
+const tableFeed = ({ db, schema, intervalMs = 1e3, report }) => {
+	const listeners = /* @__PURE__ */ new Set();
+	let cursor;
+	const read = async (from) => {
+		for (;;) {
+			const notices = await noticesAfter(db, schema, from, batchSize);
+			if (notices.length === 0) return from;
+			from = notices.at(-1).id;
+			for (const listener of listeners) listener(notices);
+			if (notices.length < batchSize) return from;
+		}
+	};
+	const tick = async (last) => {
+		if (listeners.size === 0) {
+			cursor = void 0;
+			return;
+		}
+		cursor = read(last).catch((error) => {
+			report(error);
+			return last;
+		});
+		const next = await cursor;
+		setTimeout(() => void tick(next), intervalMs);
+	};
+	const start = () => {
+		const first = lastNotice(db, schema);
+		cursor = first;
+		first.then((last) => setTimeout(() => void tick(last), intervalMs), () => cursor = void 0);
+		return first;
+	};
+	return {
+		subscribe: (listener) => {
+			listeners.add(listener);
+			const stop = () => void listeners.delete(listener);
+			return (cursor ?? start()).then((at) => ({
+				cursor: at,
+				stop
+			}), (error) => {
+				stop();
+				throw error;
+			});
+		},
+		replay: async (from, upTo, limit) => {
+			if (!await noticeKept(db, schema, from)) return void 0;
+			if (!after(upTo, from)) return [];
+			const notices = (await noticesAfter(db, schema, from, limit + 1)).filter((notice) => !after(notice.id, upTo));
+			return notices.length > limit ? void 0 : notices;
+		}
+	};
+};
+//#endregion
+export { tableFeed };

package/dist/live/notices-sql.js

@@ -0,0 +1,59 @@
+import { quoteIdent } from "../changes/capture-sql.js";
+import { sql } from "kysely";
+//#region src/live/notices-sql.ts
+/**
+* The recent changes of the resources with `.live()`, which open pages refresh from: a row per record and transaction,
+* its key and never its values. `id` grows in commit order, since one dispatch writes at a time.
+*/
+const noticesTableSql = (schema) => {
+	const table = `${quoteIdent(schema)}."notices"`;
+	return `create table if not exists ${table} (
+  "id" bigint generated always as identity primary key,
+  "resource" text not null,
+  "record_key" text not null,
+  "tenant_id" text,
+  "operation" text not null check ("operation" in ('create', 'update', 'delete', 'undelete')),
+  "at" timestamptz not null default now()
+);
+create index if not exists "notices_at" on ${table} ("at")`;
+};
+const noticeOf = (row) => ({
+	id: row.id,
+	resource: row.resource,
+	key: row.record_key,
+	operation: row.operation,
+	tenant: row.tenant_id
+});
+const tableOf = (schema) => sql.raw(`${quoteIdent(schema)}."notices"`);
+/**
+* Adds the changes as notices, in their order, and deletes those older than `keptMinutes`, but never the newest, so a
+* reader's last notice is gone only once a later one was pruned. One dispatch's transaction does both.
+*/
+const writeNotices = async (db, schema, changes) => {
+	if (changes.length === 0) return;
+	const table = tableOf(schema);
+	const rows = JSON.stringify(changes.map((change) => ({
+		resource: change.resource,
+		record_key: change.key,
+		tenant_id: change.tenant === void 0 ? null : String(change.tenant),
+		operation: change.operation
+	})));
+	await sql`insert into ${table} ("resource", "record_key", "tenant_id", "operation")
+    select "resource", "record_key", "tenant_id", "operation" from rows from (jsonb_to_recordset(${rows}::jsonb) as ("resource" text, "record_key" text, "tenant_id" text, "operation" text)) with ordinality as r("resource", "record_key", "tenant_id", "operation", "position")
+    order by "position"`.execute(db);
+	await sql`delete from ${table} where "at" < now() - make_interval(mins => ${10}) and "id" < (select max("id") from ${table})`.execute(db);
+};
+/** The newest notice's id, `0` without any. */
+const lastNotice = async (db, schema) => (await sql`select coalesce(max("id"), 0)::text as id from ${tableOf(schema)}`.execute(db)).rows[0].id;
+/** At most `limit` notices after `after`, in order. */
+const noticesAfter = async (db, schema, after, limit) => {
+	const { rows } = await sql`select "id"::text as id, "resource", "record_key", "tenant_id", "operation" from ${tableOf(schema)}
+    where "id" > ${after}::bigint order by "id" limit ${limit}`.execute(db);
+	return rows.map(noticeOf);
+};
+/** Whether the notice `id` is still kept; `0`, the cursor of an empty table, only while the table is empty still. */
+const noticeKept = async (db, schema, id) => {
+	return (await (id === "0" ? sql`select not exists (select from ${tableOf(schema)}) as kept` : sql`select exists (select from ${tableOf(schema)} where "id" = ${id}::bigint) as kept`).execute(db)).rows[0].kept;
+};
+//#endregion
+export { lastNotice, noticeKept, noticesAfter, noticesTableSql, writeNotices };

package/dist/live/visible-notices.js

@@ -0,0 +1,18 @@
+import { requestAccess } from "../request-access.js";
+//#region src/live/visible-notices.ts
+/**
+* Which notices a caller hears of: those of the live resources they may list or read, in their tenant. A notice names
+* a record, never its values, and the page reads the record again as the caller, so no row filter applies here.
+*/
+const visibleNotices = async (deps, session) => {
+	const readable = /* @__PURE__ */ new Map();
+	for (const entry of deps.registry.entries.filter((candidate) => candidate.model.live)) {
+		const { operations } = (await requestAccess(deps, entry, session)).resolved;
+		if (!operations.list && !operations.read) continue;
+		if (entry.model.tenant && session.tenant === void 0) continue;
+		readable.set(entry.name, entry.model.tenant ? String(session.tenant) : void 0);
+	}
+	return (notice) => readable.has(notice.resource) && (readable.get(notice.resource) === void 0 || readable.get(notice.resource) === notice.tenant);
+};
+//#endregion
+export { visibleNotices };

package/dist/meta.js

@@ -36,11 +36,17 @@ const createMeta = (deps, appName) => {
 		const listed = Object.fromEntries(visible.map((access) => [access.entry.name, access.model]));
 		const signIn = session.anonymous ? accesses.filter((access) => !visible.includes(access)).flatMap((access) => signInView(pickView(deps.views, session.user.roles, access.entry.name))) : [];
 		const prompted = new Set(signIn.map((entry) => entry.resource));
-		const views = visible.flatMap((access) => {
+		const picked = visible.flatMap((access) => {
 			const view = pickView(deps.views, session.user.roles, access.entry.name);
-			return view ? [pruneView(view, access.readable, listed, prompted)] : [];
+			return view ? [{
+				access,
+				view
+			}] : [];
 		});
+		const createPages = new Set(picked.filter(({ view }) => view.create).map(({ view }) => view.resource));
+		const views = picked.map(({ access, view }) => pruneView(view, access.readable, listed, prompted, createPages));
 		const callerAccess = {
+			createPages,
 			models: listed,
 			permissions: Object.fromEntries(visible.map(({ entry, resolved }) => [entry.name, {
 				create: resolved.operations.create,

package/dist/view-access.js

@@ -233,10 +233,11 @@ const layoutShape = (resource, model, models) => {
 		}, { requires: ["items"] })
 	});
 };
-const linkShape = (model, models) => shapes.map((run) => {
+const linkShape = (model, models, createPages) => shapes.map((run) => {
 	return ("to" in run ? addressErrors(run.to, {
 		models,
-		source: model
+		source: model,
+		createPages
 	}).length === 0 : hrefPlaceholders(run.href).every((name) => Object.hasOwn(model.fields, name))) ? run : void 0;
 });
 const aiShape = (model) => shapes.map((run) => {
@@ -246,7 +247,7 @@ const aiShape = (model) => shapes.map((run) => {
 	} : void 0;
 });
 const inputsShape = (models) => shapes.map((inputs) => inputs.every((input) => input.resource === void 0 || Object.hasOwn(models, input.resource)) ? inputs : void 0);
-const actionShape = (model, models) => shapes.object({
+const actionShape = (model, models, createPages) => shapes.object({
 	name: shapes.data,
 	label: shapes.data,
 	icon: shapes.data,
@@ -258,12 +259,12 @@ const actionShape = (model, models) => shapes.object({
 			values: shapes.keys({ all: true })
 		}, { requires: ["values"] }),
 		delete: shapes.data,
-		link: linkShape(model, models),
+		link: linkShape(model, models, createPages),
 		ai: aiShape(model)
 	}),
 	inputs: inputsShape(models)
 }, { requires: ["run", "inputs"] });
-const viewShape = (resource, model, models, prompted) => {
+const viewShape = (resource, model, models, prompted, createPages) => {
 	const nav = shapes.object({
 		hidden: shapes.data,
 		group: shapes.data,
@@ -291,7 +292,7 @@ const viewShape = (resource, model, models, prompted) => {
 		recordMode: shapes.data,
 		helpWhen: shapes.data,
 		saveFeedback: shapes.data,
-		actions: shapes.list(actionShape(model, models)),
+		actions: shapes.list(actionShape(model, models, createPages)),
 		listOf: shapes.field,
 		signIn: shapes.data,
 		saveSearch: shapes.map((search) => prompted.has(search.resource) || models[search.resource] ? search : void 0),
@@ -317,10 +318,11 @@ const viewShape = (resource, model, models, prompted) => {
 * actions that set or read one, and the sidebar's `recent` group. Nothing in it may name a hidden field. Related sections, related list columns
 * and links are checked against `models`, the caller's view of every resource, and so are `searchesOf`, cards' favorite
 * buttons and the "Save search" button; the buttons stay for a visitor when their resource is one of `prompted`, those
-* that ask the visitor to sign in.
+* that ask the visitor to sign in. A create link may give values of any name to a resource of `createPages`, whose view
+* for the caller opens a create page.
 */
-const pruneView = (view, model, models, prompted = /* @__PURE__ */ new Set()) => {
-	const pruned = pruneByShape(view, viewShape(view.resource, model, models, prompted), (name) => Object.hasOwn(model.fields, name));
+const pruneView = (view, model, models, prompted = /* @__PURE__ */ new Set(), createPages = /* @__PURE__ */ new Set()) => {
+	const pruned = pruneByShape(view, viewShape(view.resource, model, models, prompted, createPages), (name) => Object.hasOwn(model.fields, name));
 	if (!pruned) throw new Error(`The view of ${view.resource} is not an object`);
 	return pruned;
 };

package/dist/webhooks/webhooks.js

@@ -1,6 +1,7 @@
 import { dispatchJobName, isCaptured } from "../changes/capture-sql.js";
 import { defineJob } from "../jobs/define-job.js";
 import { FatalJobError } from "../jobs/run-job.js";
+import { writeNotices } from "../live/notices-sql.js";
 import { coalesce } from "../changes/coalesce.js";
 import { EventCodeError } from "../changes/event-code-error.js";
 import { eventMatcher } from "../changes/match-events.js";
@@ -233,6 +234,7 @@ const createWebhooks = ({ deps, subscriptions, functions, schema, log, table })
 			await queueOrdered(trx, deliveries);
 			for (const { change } of failures) await dispatchChange.enqueue(trx, { change });
 			await writeHistory(trx, schema, changes.filter((change) => deps.registry.find(change.resource)?.model.history));
+			await writeNotices(trx, schema, changes.filter((change) => deps.registry.find(change.resource)?.model.live));
 			await deleteOutbox(trx, schema, rows.map((row) => row.id));
 		});
 		for (const [index, { subscription, event }] of now.entries()) report(subscription.name, event, 1, results[index]);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@protobase/server",
-  "version": "0.23.3",
+  "version": "0.23.4",
   "description": "The Protobase REST API as a Hono app, with Better Auth sign-in.",
   "license": "Apache-2.0",
   "repository": {
@@ -31,9 +31,9 @@
   "dependencies": {
     "@better-auth/passkey": "^1.7.7",
     "@better-auth/sso": "^1.7.7",
-    "@protobase/layout": "0.23.3",
-    "@protobase/query": "0.23.3",
-    "@protobase/schema": "0.23.3",
+    "@protobase/layout": "0.23.4",
+    "@protobase/query": "0.23.4",
+    "@protobase/schema": "0.23.4",
     "@react-email/render": "^2.1.0",
     "@scalar/hono-api-reference": "^0.12.10",
     "@sentry/core": "^11.7.0",