@protobase/server 0.58.7 → 0.59.0

package/dist/realtime/relay/relay-frame-sql.js

@@ -12,7 +12,7 @@ const jsonOf = (payload) => payload instanceof ArrayBuffer ? null : JSON.stringi
 * Counts the broadcasts into each topic's second, every process's together, and adds them as frames, all of them or,
 * when a topic would take more than its broadcasts for this second, none: `false` then.
 */
-const admitBroadcasts = async (db, statementTimeoutMs, self, publications) => {
+const admitBroadcasts = async (db, statementTimeoutMs, self, space, publications) => {
 	if (publications.length === 0) return true;
 	const takes = /* @__PURE__ */ new Map();
 	for (const { topic } of publications) takes.set(topic, (takes.get(topic) ?? 0) + 1);
@@ -24,8 +24,8 @@ const admitBroadcasts = async (db, statementTimeoutMs, self, publications) => {
         where r.second <> excluded.second or r.count + excluded.count <= ${realtimeLimits.topicBroadcastsPerSecond}
       returning topic`.execute(trx);
 		if (rows.length < takes.size) throw new Refused();
-		await sql`insert into realtime_relay.frames (process, kind, topic, private, event, payload, bytes, meta)
-      select ${self}::uuid, 'broadcast', topic, private, event, payload::json, decode(bytes, 'base64'), meta::json
+		await sql`insert into realtime_relay.frames (process, kind, space, topic, private, event, payload, bytes, meta)
+      select ${self}::uuid, 'broadcast', ${space}::text, topic, private, event, payload::json, decode(bytes, 'base64'), meta::json
       from unnest(${publications.map((p) => p.topic)}::text[], ${publications.map((p) => p.private)}::boolean[], ${publications.map((p) => p.event)}::text[],
         ${publications.map((p) => jsonOf(p.payload))}::text[], ${publications.map((p) => bytesOf(p.payload))}::text[], ${publications.map((p) => p.meta ? JSON.stringify(p.meta) : null)}::text[])
         with ordinality as f(topic, private, event, payload, bytes, meta, position)
@@ -38,8 +38,10 @@ const admitBroadcasts = async (db, statementTimeoutMs, self, publications) => {
 };
 const frameOf = (row) => {
 	const id = BigInt(row.id);
+	const { space } = row;
 	if (row.kind === "presence") return {
 		id,
+		space,
 		kind: "presence",
 		topic: row.topic,
 		private: row.private,
@@ -48,6 +50,7 @@ const frameOf = (row) => {
 	const payload = row.bytes ? new Uint8Array(row.bytes).buffer : row.payload;
 	return {
 		id,
+		space,
 		kind: "broadcast",
 		publication: {
 			topic: row.topic,
@@ -63,7 +66,7 @@ const frameOf = (row) => {
 * other processes' frames, to deliver.
 */
 const readFrames = async (db, self, after, gaps) => {
-	const { rows } = await sql`select id::text as id, process = ${self}::uuid as own, kind, topic, private, event,
+	const { rows } = await sql`select id::text as id, process = ${self}::uuid as own, kind, space, topic, private, event,
       case when process <> ${self}::uuid then payload end as payload, case when process <> ${self}::uuid then bytes end as bytes, meta
     from realtime_relay.frames where id > ${String(after)}::bigint or id = any(${gaps.map(String)}::bigint[])
     order by id limit ${frameBatch}`.execute(db);

package/dist/realtime/relay/relay-presence-sql.js

@@ -12,23 +12,23 @@ const joinFrame = sql.raw(`json_build_object('joins', json_build_object(key, jso
 * Keeps the change in `presences` and adds its frame, in one statement: a leave alone is sent only when the presence
 * was there, as a process that was taken for stopped had its presences removed already.
 */
-const writePresence = async (db, self, change) => {
+const writePresence = async (db, self, space, change) => {
 	const ref = change.joined?.phx_ref ?? null;
 	await sql`with gone as (delete from realtime_relay.presences where process = ${self}::uuid and ref = ${change.left?.phx_ref ?? null}::text returning ref),
-      added as (insert into realtime_relay.presences (process, ref, topic, private, key, meta)
-        select ${self}::uuid, ${ref}::text, ${change.topic}::text, ${change.private}::boolean, ${change.key}::text, ${JSON.stringify(change.joined ?? null)}::json where ${ref}::text is not null)
-    insert into realtime_relay.frames (process, kind, topic, private, payload)
-    select ${self}::uuid, 'presence', ${change.topic}::text, ${change.private}::boolean, ${JSON.stringify(diffOf(change))}::json
+      added as (insert into realtime_relay.presences (process, ref, space, topic, private, key, meta)
+        select ${self}::uuid, ${ref}::text, ${space}::text, ${change.topic}::text, ${change.private}::boolean, ${change.key}::text, ${JSON.stringify(change.joined ?? null)}::json where ${ref}::text is not null)
+    insert into realtime_relay.frames (process, kind, space, topic, private, payload)
+    select ${self}::uuid, 'presence', ${space}::text, ${change.topic}::text, ${change.private}::boolean, ${JSON.stringify(diffOf(change))}::json
     where ${ref}::text is not null or exists (select from gone)`.execute(db);
 };
 /** Adds the presences back, with their joins, for a process that was taken for stopped while it was not. */
 const restorePresences = async (db, self, tracked) => {
 	if (tracked.length === 0) return;
-	await sql`with added as (insert into realtime_relay.presences (process, ref, topic, private, key, meta)
-        select ${self}::uuid, ref, topic, private, key, meta::json from unnest(${tracked.map((t) => t.meta.phx_ref)}::text[], ${tracked.map((t) => t.topic)}::text[],
-          ${tracked.map((t) => t.private)}::boolean[], ${tracked.map((t) => t.key)}::text[], ${tracked.map((t) => JSON.stringify(t.meta))}::text[]) as t(ref, topic, private, key, meta)
-        on conflict do nothing returning process, topic, private, key, meta)
-    insert into realtime_relay.frames (process, kind, topic, private, payload) select process, 'presence', topic, private, ${joinFrame} from added`.execute(db);
+	await sql`with added as (insert into realtime_relay.presences (process, ref, space, topic, private, key, meta)
+        select ${self}::uuid, ref, space, topic, private, key, meta::json from unnest(${tracked.map((t) => t.meta.phx_ref)}::text[], ${tracked.map((t) => t.space)}::text[], ${tracked.map((t) => t.topic)}::text[],
+          ${tracked.map((t) => t.private)}::boolean[], ${tracked.map((t) => t.key)}::text[], ${tracked.map((t) => JSON.stringify(t.meta))}::text[]) as t(ref, space, topic, private, key, meta)
+        on conflict do nothing returning process, space, topic, private, key, meta)
+    insert into realtime_relay.frames (process, kind, space, topic, private, payload) select process, 'presence', space, topic, private, ${joinFrame} from added`.execute(db);
 };
 /**
 * Marks this process as running, by the database's clock: `true` when its row was not there, as at its start or once
@@ -41,8 +41,8 @@ const beat = async (db, self) => {
 };
 const retire = (db, dead) => sql`with dead as (delete from realtime_relay.processes where ${dead} returning id),
       gone as (delete from realtime_relay.presences p where p.process in (select id from dead) or not exists (select from realtime_relay.processes q where q.id = p.process)
-        returning process, topic, private, key, meta)
-    insert into realtime_relay.frames (process, kind, topic, private, payload) select process, 'presence', topic, private, ${leaveFrame} from gone`.execute(db);
+        returning process, space, topic, private, key, meta)
+    insert into realtime_relay.frames (process, kind, space, topic, private, payload) select process, 'presence', space, topic, private, ${leaveFrame} from gone`.execute(db);
 /** Removes the processes that have not beaten for `staleSeconds`, and their presences. */
 const retireStale = async (db, staleSeconds) => {
 	await retire(db, sql`seen_at < now() - make_interval(secs => ${staleSeconds})`);
@@ -57,7 +57,7 @@ const retireSelf = async (db, self) => {
 */
 const presenceSnapshot = (db, statementTimeoutMs, self) => db.transaction().setIsolationLevel("repeatable read").execute(async (trx) => {
 	await sql`select set_config('statement_timeout', ${String(statementTimeoutMs)}, true)`.execute(trx);
-	const presences = await sql`select topic, private, key, meta from realtime_relay.presences where process <> ${self}::uuid`.execute(trx);
+	const presences = await sql`select space, topic, private, key, meta from realtime_relay.presences where process <> ${self}::uuid`.execute(trx);
 	const newest = await sql`select coalesce(max(id), 0)::text as id from realtime_relay.frames`.execute(trx);
 	const recent = await sql`select id::text as id from realtime_relay.frames
       where id >= (select min(id) from realtime_relay.frames where at > now() - interval '2 seconds') order by id`.execute(trx);

package/dist/realtime/relay/relay-schema-sql.js

@@ -8,8 +8,12 @@ const relayTables = [
 	"processes",
 	"rates"
 ];
+/** The tables with a `space` column, which a relay schema written before it lacks. */
+const spacedTables = ["frames", "presences"];
 /**
 * - `frames`: what a process sends, a broadcast or a presence diff, read by the others and pruned after a minute.
+* - `space` in `frames` and `presences`: the channels they are of (`RelaySpace`), `topics` for a row written without
+*   one, as by a process of a version before the record channels.
 * - `presences`: what each process's channels track, which a process that starts reads.
 * - `processes`: each process's last heartbeat; a process silent too long has its presences removed.
 * - `rates`: each topic's broadcasts in the current second, every process's together.
@@ -22,6 +26,7 @@ create table if not exists ${relaySchema}.frames (
   kind text not null check (kind in ('broadcast', 'presence')),
   topic text not null,
   private boolean not null,
+  space text not null default 'topics' check (space in ('topics', 'records')),
   event text,
   payload json,
   bytes bytea,
@@ -41,6 +46,7 @@ create table if not exists ${relaySchema}.presences (
   ref text not null,
   topic text not null,
   private boolean not null,
+  space text not null default 'topics' check (space in ('topics', 'records')),
   key text not null,
   meta json not null,
   primary key (process, ref)
@@ -50,6 +56,9 @@ create table if not exists ${relaySchema}.rates (
   topic text primary key,
   second bigint not null,
   count integer not null
-);`;
+);
+
+-- A relay schema written before the record channels gets the column too.
+${spacedTables.map((table) => `alter table ${relaySchema}.${table} add column if not exists space text not null default 'topics' check (space in ('topics', 'records'));`).join("\n")}`;
 //#endregion
-export { relaySchema, relaySchemaSql, relayTables };
+export { relaySchema, relaySchemaSql, relayTables, spacedTables };

package/dist/realtime/relay/relay-schema.d.ts

@@ -1,7 +1,7 @@
 import { Db } from "@protobase/query";
 //#region src/realtime/relay/relay-schema.d.ts
 /** The SQL that adds the `realtime_relay` schema `realtime: { processes: 'many' }` needs; `undefined` when it is there. */
-export declare const realtimeRelayMigration: (db: Db) => Promise<"create schema if not exists realtime_relay;\n\ncreate table if not exists realtime_relay.frames (\n  id bigint generated always as identity primary key,\n  process uuid not null,\n  kind text not null check (kind in ('broadcast', 'presence')),\n  topic text not null,\n  private boolean not null,\n  event text,\n  payload json,\n  bytes bytea,\n  meta json,\n  at timestamptz not null default now()\n);\n\ncreate index if not exists frames_at on realtime_relay.frames (at);\n\ncreate table if not exists realtime_relay.processes (\n  id uuid primary key,\n  seen_at timestamptz not null default now()\n);\n\ncreate table if not exists realtime_relay.presences (\n  process uuid not null,\n  ref text not null,\n  topic text not null,\n  private boolean not null,\n  key text not null,\n  meta json not null,\n  primary key (process, ref)\n);\n\ncreate table if not exists realtime_relay.rates (\n  topic text primary key,\n  second bigint not null,\n  count integer not null\n);" | undefined>;
+export declare const realtimeRelayMigration: (db: Db) => Promise<string | undefined>;
 /** Refuses to go on while the `realtime_relay` schema is missing; the project's migrations add it. */
 export declare const checkRealtimeRelay: (db: Db) => Promise<void>;
 //#endregion

package/dist/realtime/relay/relay-schema.js

@@ -1,11 +1,13 @@
 import { migrationCommand } from "../../changes/capture-schema.js";
-import { relaySchema, relaySchemaSql, relayTables } from "./relay-schema-sql.js";
+import { relaySchema, relaySchemaSql, relayTables, spacedTables } from "./relay-schema-sql.js";
 import { sql } from "kysely";
 //#region src/realtime/relay/relay-schema.ts
 const relayCurrent = async (db) => {
 	const names = relayTables.map((table) => `${relaySchema}.${table}`);
 	const { rows } = await sql`select bool_and(to_regclass(name) is not null) as found from unnest(${names}::text[]) as name`.execute(db);
-	return rows[0].found;
+	if (!rows[0].found) return false;
+	return (await sql`select count(*)::int as count from information_schema.columns
+    where table_schema = ${relaySchema} and table_name = any(${[...spacedTables]}::text[]) and column_name = 'space'`.execute(db)).rows[0].count === spacedTables.length;
 };
 /** The SQL that adds the `realtime_relay` schema `realtime: { processes: 'many' }` needs; `undefined` when it is there. */
 const realtimeRelayMigration = async (db) => await relayCurrent(db) ? void 0 : relaySchemaSql;

package/dist/realtime/relay/relayed-hubs.js

@@ -4,56 +4,79 @@ import { presenceReplica } from "./presence-replica.js";
 import { realtimeRelay } from "./realtime-relay.js";
 //#region src/realtime/relay/relayed-hubs.ts
 /**
-* The broadcast and presence hubs of `realtime: { processes: 'many' }`: this process's channels in memory, as with one
-* process, and every broadcast and presence change written to the relay for the other processes, whose own reach the
-* channels here as the relay reads them. A topic's private and public channels stay apart across processes too. A
-* broadcast reaches this process's channels once the relay admitted it under the topic's rate. `follow` reads the
-* relay while a socket is open.
+* The broadcast and presence hubs of `realtime: { processes: 'many' }`, one pair for each space (`RelaySpace`): this
+* process's channels in memory, as with one process, and every broadcast and presence change written to the relay for
+* the other processes, whose own reach the channels here as the relay reads them, in the space they were sent in. A
+* topic's private and public channels stay apart across processes too. A broadcast reaches this process's channels
+* once the relay admitted it under the topic's rate. `follow` reads the relay while a socket is open.
 */
 const relayedHubs = ({ db, statementTimeoutMs, report }) => {
-	const local = broadcastHub();
-	const replica = presenceReplica();
+	const spaces = /* @__PURE__ */ new Map();
 	const relay = realtimeRelay({
 		db,
 		statementTimeoutMs,
 		report,
 		heard: (frame) => {
-			if (frame.kind === "broadcast") return local.deliver(frame.publication);
-			const diff = replica.apply(frame.topic, frame.private, frame.diff);
-			if (diff) presences.hear(frame.topic, frame.private, diff);
+			const space = spaces.get(frame.space);
+			if (!space) return;
+			if (frame.kind === "broadcast") return space.local.deliver(frame.publication);
+			const diff = space.replica.apply(frame.topic, frame.private, frame.diff);
+			if (diff) space.presences.hear(frame.topic, frame.private, diff);
 		},
-		loaded: replica.load,
-		tracked: () => presences.tracked()
-	});
-	const presences = presenceHub({
-		refPrefix: `${relay.id}:`,
-		remote: {
-			state: replica.state,
-			changed: relay.changed,
-			ready: relay.ready
-		}
+		loaded: (tracked) => {
+			for (const [name, space] of spaces) space.replica.load(tracked.filter((presence) => presence.space === name));
+		},
+		tracked: () => [...spaces].flatMap(([name, space]) => space.presences.tracked().map((presence) => ({
+			space: name,
+			...presence
+		})))
 	});
-	return {
-		broadcasts: {
-			join: local.join,
-			send: async (topic, from, event, payload) => {
-				const publication = {
-					topic,
-					event,
-					payload,
-					private: from.private
-				};
-				if (!await relay.broadcast([publication])) return false;
-				local.deliver(publication, from);
-				return true;
-			},
-			publish: async (publications) => {
-				if (!await relay.broadcast(publications)) return false;
-				for (const publication of publications) local.deliver(publication);
-				return true;
+	const spaceOf = (name) => {
+		const local = broadcastHub();
+		const replica = presenceReplica();
+		return {
+			local,
+			replica,
+			presences: presenceHub({
+				refPrefix: `${relay.id}:`,
+				remote: {
+					state: replica.state,
+					changed: (change) => relay.changed(name, change),
+					ready: relay.ready
+				}
+			}),
+			broadcasts: {
+				join: local.join,
+				send: async (topic, from, event, payload) => {
+					const publication = {
+						topic,
+						event,
+						payload,
+						private: from.private
+					};
+					if (!await relay.broadcast(name, [publication])) return false;
+					local.deliver(publication, from);
+					return true;
+				},
+				publish: async (publications) => {
+					if (!await relay.broadcast(name, publications)) return false;
+					for (const publication of publications) local.deliver(publication);
+					return true;
+				}
 			}
-		},
-		presences,
+		};
+	};
+	for (const name of ["topics", "records"]) spaces.set(name, spaceOf(name));
+	const hubsOf = (name) => {
+		const { broadcasts, presences } = spaces.get(name);
+		return {
+			broadcasts,
+			presences
+		};
+	};
+	return {
+		topics: hubsOf("topics"),
+		records: hubsOf("records"),
 		follow: relay.follow
 	};
 };

package/dist/webhooks/attempt.js

@@ -53,6 +53,7 @@ const callFunction = async (name, subscription, event, options, context, signal)
 	const functionContext = {
 		name,
 		db: context.db,
+		channels: context.channels,
 		caller: async () => caller,
 		acceptWebSocket,
 		calls: { join: async () => acceptWebSocket() }

package/dist/webhooks/webhooks.js

@@ -60,7 +60,7 @@ const deliveryGroup = ({ subscription, change }) => `${subscription.name}:${chan
 *
 * No jobs without a resource with events or history; the subscriptions must name declared events.
 */
-const createWebhooks = ({ deps, subscriptions, functions, schema, log, table }) => {
+const createWebhooks = ({ deps, subscriptions, functions, channels, schema, log, table }) => {
 	const entries = deps.registry.entries;
 	const models = entries.map((entry) => entry.model);
 	const problems = subscriptionProblems(subscriptions, models, Object.keys(functions));
@@ -82,6 +82,7 @@ const createWebhooks = ({ deps, subscriptions, functions, schema, log, table })
 			db,
 			functions,
 			records,
+			channels,
 			attempt: tried,
 			signal,
 			...checkUrl && { checkUrl }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@protobase/server",
-  "version": "0.58.7",
+  "version": "0.59.0",
   "description": "The Protobase REST API as a Hono app, with Better Auth sign-in.",
   "license": "Apache-2.0",
   "repository": {
@@ -42,9 +42,9 @@
     "@better-auth/sso": "^1.7.12",
     "@livekit/protocol": "1.53.1",
     "@modelcontextprotocol/server": "^2.3.1",
-    "@protobase/layout": "0.58.7",
-    "@protobase/query": "0.58.7",
-    "@protobase/schema": "0.58.7",
+    "@protobase/layout": "0.59.0",
+    "@protobase/query": "0.59.0",
+    "@protobase/schema": "0.59.0",
     "@react-email/render": "^2.1.0",
     "@scalar/hono-api-reference": "^0.12.10",
     "@sentry/core": "^11.7.0",