@protobase/server 0.59.1 → 0.59.3

package/dist/better-auth/store/migrations-table.js

@@ -1,5 +1,5 @@
-import { ddl, ddlText } from "./ddl.js";
 import { storeTable } from "./store-names.js";
+import { ddl, ddlText } from "./ddl.js";
 import { sql } from "kysely";
 //#region src/better-auth/store/migrations-table.ts
 /** The table, in the store's schema. */

package/dist/channels/binary-frame.js

@@ -0,0 +1,44 @@
+//#region src/channels/binary-frame.ts
+const encoder = new TextEncoder();
+const decoder = new TextDecoder();
+const lengthBytes = 4;
+/**
+* A binary frame of `/api/channels`: the byte length of a JSON header, the header, then the bytes it carries. A binary
+* broadcast travels as one, its header the message without its payload.
+*/
+const encodeBinaryFrame = (header, bytes) => {
+	const head = encoder.encode(JSON.stringify(header));
+	const frame = new Uint8Array(lengthBytes + head.length + bytes.byteLength);
+	new DataView(frame.buffer).setUint32(0, head.length);
+	frame.set(head, lengthBytes);
+	frame.set(new Uint8Array(bytes), lengthBytes + head.length);
+	return frame.buffer;
+};
+/** The header and bytes of a binary frame, or `undefined` for one cut short or whose header is not a JSON object. */
+const decodeBinaryFrame = (frame) => {
+	if (frame.byteLength < lengthBytes) return;
+	const end = lengthBytes + new DataView(frame).getUint32(0);
+	if (end > frame.byteLength) return;
+	const header = parsed(decoder.decode(new Uint8Array(frame, lengthBytes, end - lengthBytes)));
+	if (typeof header !== "object" || header === null || Array.isArray(header)) return;
+	return {
+		header,
+		bytes: frame.slice(end)
+	};
+};
+const parsed = (text) => {
+	try {
+		return JSON.parse(text);
+	} catch (error) {
+		if (error instanceof SyntaxError) return;
+		throw error;
+	}
+};
+/** The bytes of an `ArrayBuffer` or a typed array, as an `ArrayBuffer` of their own; `undefined` for anything else. */
+const bytesOf = (value) => {
+	if (value instanceof ArrayBuffer) return value;
+	if (!ArrayBuffer.isView(value)) return;
+	return new Uint8Array(value.buffer, value.byteOffset, value.byteLength).slice().buffer;
+};
+//#endregion
+export { bytesOf, decodeBinaryFrame, encodeBinaryFrame };

package/dist/channels/channel-protocol.js

@@ -1,9 +1,22 @@
+import { decodeBinaryFrame } from "./binary-frame.js";
 //#region src/channels/channel-protocol.ts
 const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
 const text = (value) => typeof value === "string";
 /** The message a text frame carries, or `undefined` for one that is not JSON or not a message. */
-const decodeClientMessage = (frame) => {
-	const message = parsed(frame);
+const decodeClientMessage = (frame) => messageOf(parsed(frame));
+/**
+* The send of bytes a binary frame carries (`decodeBinaryFrame`): its header a `send` without a payload, its bytes the
+* payload. `undefined` for any other frame.
+*/
+const decodeBinaryMessage = (frame) => {
+	const decoded = decodeBinaryFrame(frame);
+	if (!decoded || decoded.header.type !== "send" || "payload" in decoded.header) return;
+	return messageOf({
+		...decoded.header,
+		payload: decoded.bytes
+	});
+};
+const messageOf = (message) => {
 	if (!isRecord(message)) return;
 	if (message.ref !== void 0 && !text(message.ref)) return;
 	const { type } = message;
@@ -30,4 +43,4 @@ const parsed = (frame) => {
 	}
 };
 //#endregion
-export { decodeClientMessage };
+export { decodeBinaryMessage, decodeClientMessage };

package/dist/channels/channel-refusals.js

@@ -10,7 +10,7 @@ const refusal = (code, message) => ({
 */
 const channelRefusals = {
 	notFound: refusal("not-found", "There is no such record"),
-	invalidMessage: refusal("invalid-message", "Send a JSON text frame of a ping, token, join, leave, track, untrack or send"),
+	invalidMessage: refusal("invalid-message", "Send a JSON text frame of a ping, token, join, leave, track, untrack or send, or a binary frame of a send"),
 	notJoined: refusal("not-joined", "Join the channel first"),
 	alreadyJoined: refusal("already-joined", "This connection has joined the channel already"),
 	nameTooLong: refusal("name-too-long", "A channel name, its resource, a slash and its key, is at most 255 bytes"),

package/dist/channels/channel-routes.js

@@ -16,11 +16,30 @@ const withBearer = (request, token) => {
 	headers.set("authorization", `Bearer ${token}`);
 	return new Request(request, { headers });
 };
-const invalidBody = () => new HttpProblem(422, "invalid-broadcast", "Unprocessable Content", "Send { \"event\": \"…\", \"payload\": … } as application/json");
+const invalidBody = () => new HttpProblem(422, "invalid-broadcast", "Unprocessable Content", "Send { \"event\": \"…\", \"payload\": … } as application/json, or bytes as application/octet-stream with ?event=…");
+const broadcastOf = async (request) => {
+	if (request.header("content-type")?.split(";")[0].trim().toLowerCase() === "application/octet-stream") {
+		const event = request.query("event");
+		if (event === void 0) throw invalidBody();
+		return {
+			event,
+			payload: await request.arrayBuffer()
+		};
+	}
+	const body = await request.json().catch((error) => {
+		if (error instanceof SyntaxError) throw invalidBody();
+		throw error;
+	});
+	if (!isRecord(body) || typeof body.event !== "string" || !("payload" in body)) throw invalidBody();
+	return {
+		event: body.event,
+		payload: body.payload
+	};
+};
 /**
 * `GET /channels`, a WebSocket of channels named by records (see `channelSocket`), refused before the upgrade like
 * any request its caller cannot make. `POST /channels/:resource/:key/broadcast` sends one broadcast without a socket,
-* as the caller, when they may read the record.
+* as the caller, when they may read the record: JSON, or bytes (`broadcastOf`).
 */
 const channelRoutes = ({ deps, upgradeWebSocket, authenticate, authenticateUpgrade, onError, hubs, follow, report }) => {
 	const app = new Hono();
@@ -72,16 +91,10 @@ const channelRoutes = ({ deps, upgradeWebSocket, authenticate, authenticateUpgra
 			throw new HttpProblem(413, "too-large", "Payload Too Large", `A broadcast request is at most ${realtimeLimits.maxFrameBytes} bytes`);
 		}
 	}), async (c) => {
-		const body = await c.req.json().catch((error) => {
-			if (error instanceof SyntaxError) throw invalidBody();
-			throw error;
-		});
-		if (!isRecord(body) || typeof body.event !== "string" || !("payload" in body)) throw invalidBody();
 		const message = {
 			resource: c.req.param("resource"),
 			key: c.req.param("key"),
-			event: body.event,
-			payload: body.payload
+			...await broadcastOf(c.req)
 		};
 		const record = broadcastRecord(deps.registry, message);
 		const session = c.get("session");

package/dist/channels/channel-sender.d.ts

@@ -1,7 +1,7 @@
 import "../registry.js";
 import "./channel-name.js";
 //#region src/channels/channel-sender.d.ts
-/** A broadcast to the channel of a record, from outside a connection. */
+/** A broadcast to the channel of a record, from outside a connection: a JSON payload, or bytes in an `ArrayBuffer` or typed array. */
 export type ChannelBroadcast = {
   resource: string;
   key: string;

package/dist/channels/channel-sender.js

@@ -2,31 +2,43 @@ import { HttpProblem, notFound } from "../problem.js";
 import { fitsFrame } from "../realtime/broadcast-frame.js";
 import { realtimeLimits } from "../realtime/realtime-limits.js";
 import { channelRecord } from "./channel-name.js";
+import { bytesOf } from "./binary-frame.js";
 import { channelRefusals } from "./channel-refusals.js";
+import { packSent } from "./sent.js";
 import { Buffer } from "node:buffer";
 //#region src/channels/channel-sender.ts
 const invalid = (refusal) => new HttpProblem(422, refusal.code, "Unprocessable Content", refusal.message);
+const invalidPayload = {
+	code: "invalid-payload",
+	message: `A payload is JSON or bytes of at most ${realtimeLimits.maxFrameBytes} bytes`
+};
+const payloadBytes = (payload) => {
+	if (payload instanceof ArrayBuffer || ArrayBuffer.isView(payload)) return payload.byteLength;
+	const json = JSON.stringify(payload);
+	return json === void 0 ? NaN : Buffer.byteLength(json);
+};
 /** The record a broadcast names, its event and payload checked, or a problem. */
 const broadcastRecord = (registry, { resource, key, event, payload }) => {
 	const found = channelRecord(registry, resource, key);
 	if (found === "too-long") throw invalid(channelRefusals.nameTooLong);
 	if (!found) throw notFound(channelRefusals.notFound.message);
 	if (!fitsFrame(event)) throw invalid(channelRefusals.eventTooLong);
-	const json = JSON.stringify(payload);
-	if (json === void 0 || Buffer.byteLength(json) > realtimeLimits.maxFrameBytes) throw invalid({
-		code: "invalid-payload",
-		message: `A payload is JSON of at most ${realtimeLimits.maxFrameBytes} bytes`
-	});
+	if (!(payloadBytes(payload) <= realtimeLimits.maxFrameBytes)) throw invalid(invalidPayload);
 	return found;
 };
+/** A checked broadcast as the hub publishes it; a typed array's bytes go as an `ArrayBuffer` of their own. */
+const publicationTo = (record, event, sent) => ({
+	topic: record.name,
+	event,
+	payload: packSent({
+		...sent,
+		payload: bytesOf(sent.payload) ?? sent.payload
+	}),
+	private: false
+});
 /** Publishes a checked broadcast, refused with 429 when the channel took its broadcasts for this second. */
 const publishTo = async (broadcasts, record, event, sent) => {
-	if (await broadcasts.publish([{
-		topic: record.name,
-		event,
-		payload: sent,
-		private: false
-	}])) return;
+	if (await broadcasts.publish([publicationTo(record, event, sent)])) return;
 	throw new HttpProblem(429, channelRefusals.channelTooBusy.code, "Too Many Requests", channelRefusals.channelTooBusy.message);
 };
 /** The server's own sender over the record channels' hub. */
@@ -36,4 +48,4 @@ const channelSender = (registry, broadcasts) => ({ broadcast: async (message) =>
 	payload: message.payload
 }) });
 //#endregion
-export { broadcastRecord, channelSender, publishTo };
+export { broadcastRecord, channelSender, publicationTo, publishTo };

package/dist/channels/channel-socket.js

@@ -1,11 +1,12 @@
 import { fitsFrame } from "../realtime/broadcast-frame.js";
 import { realtimeLimits } from "../realtime/realtime-limits.js";
 import { fixedWindow, fixedWindows } from "../realtime/fixed-window.js";
+import { encodeBinaryFrame } from "./binary-frame.js";
 import { channelRefusals } from "./channel-refusals.js";
+import { packSent, senderOf, unpackSent } from "./sent.js";
 import { channelBounds } from "./channel-bounds.js";
-import { decodeClientMessage } from "./channel-protocol.js";
+import { decodeBinaryMessage, decodeClientMessage } from "./channel-protocol.js";
 import { entriesOf, entryDiff } from "./presence-entries.js";
-import { senderOf } from "./sent.js";
 import { randomUUID } from "node:crypto";
 import { Buffer } from "node:buffer";
 //#region src/channels/channel-socket.ts
@@ -56,6 +57,10 @@ const channelSocket = ({ send, buffered, close, session: first, reauthenticate,
 	const push = (message) => {
 		if (!open) return;
 		if (!(buffered() <= realtimeLimits.maxUnsentBytes)) return shut(policyViolation);
+		if (message.type === "broadcast" && message.payload instanceof ArrayBuffer) {
+			const { payload, ...header } = message;
+			return send(encodeBinaryFrame(header, payload));
+		}
 		send(JSON.stringify(message));
 	};
 	const ok = (ref, channel) => {
@@ -105,7 +110,7 @@ const channelSocket = ({ send, buffered, close, session: first, reauthenticate,
 		const member = {
 			self: false,
 			private: false,
-			receive: (event, payload) => hear(name, event, payload)
+			receive: (event, payload) => hear(name, event, unpackSent(payload))
 		};
 		const seat = presences.join(name, {
 			key: randomUUID(),
@@ -161,7 +166,7 @@ const channelSocket = ({ send, buffered, close, session: first, reauthenticate,
 			user: userOf(session),
 			payload: message.payload
 		};
-		if (!await broadcasts.send(message.channel, channel.member, message.event, sent)) return refuse(message.ref, channelRefusals.channelTooBusy);
+		if (!await broadcasts.send(message.channel, channel.member, message.event, packSent(sent))) return refuse(message.ref, channelRefusals.channelTooBusy);
 		if (message.self === true) hear(message.channel, message.event, sent);
 		if (message.ack === true) ok(message.ref);
 	};
@@ -224,15 +229,15 @@ const channelSocket = ({ send, buffered, close, session: first, reauthenticate,
 	};
 	return {
 		/**
-		* Handles a text frame after those before it; a binary one, or one that is not a message, gets an error. A frame
-		* over the size cap, or of a kind whose size is unknown, closes the socket.
+		* Handles a frame after those before it: a text one, or a binary `ArrayBuffer` of a send of bytes; one that is not
+		* a message gets an error. A frame over the size cap, or of a kind whose size is unknown, closes the socket.
 		*/
 		message: (frame) => {
 			if (!open) return;
 			const size = frameBytes(frame);
 			if (!(size <= realtimeLimits.maxFrameBytes)) return shut(messageTooBig);
 			stayAwake();
-			const message = typeof frame === "string" ? decodeClientMessage(frame) : void 0;
+			const message = typeof frame === "string" ? decodeClientMessage(frame) : frame instanceof ArrayBuffer ? decodeBinaryMessage(frame) : void 0;
 			if (!message) return push({
 				type: "error",
 				error: channelRefusals.invalidMessage

package/dist/channels/database-sends.js

@@ -0,0 +1,57 @@
+import { HttpProblem } from "../problem.js";
+import { writeTransaction } from "../transactions.js";
+import { followedPoll } from "../realtime/followed-poll.js";
+import { broadcastRecord, publicationTo } from "./channel-sender.js";
+import { sendsSchema } from "./sends-schema-sql.js";
+import { sql } from "kysely";
+//#region src/channels/database-sends.ts
+/** Sends taken in one transaction at most. */
+const batchSize = 1e3;
+/**
+* The broadcast a row sends, as the server, under the checks of `channels.broadcast` in API functions; `undefined` for
+* one they refuse, such as for a record the app does not have or a payload over a frame, which is dropped.
+*/
+const publicationOfSend = (registry, row) => {
+	try {
+		const record = broadcastRecord(registry, row);
+		return publicationTo(record, row.event, {
+			user: null,
+			server: true,
+			payload: row.payload
+		});
+	} catch (error) {
+		if (error instanceof HttpProblem) return;
+		throw error;
+	}
+};
+const takeSends = (db, statementTimeoutMs) => writeTransaction(db, statementTimeoutMs, async (trx) => {
+	const { rows } = await sql`with taken as (
+        delete from ${sql.id(sendsSchema, "sends")} where id in (
+          select id from ${sql.id(sendsSchema, "sends")} order by id limit ${batchSize} for update skip locked
+        ) returning id, resource, key, event, payload
+      )
+      select id::text as id, resource, key, event, payload from taken order by id`.execute(trx);
+	return rows;
+});
+/**
+* SQL's broadcasts to the record channels: `channels.send()` inserts a row in the caller's transaction, so only a
+* committed one is seen, and while a record channel's socket of this process is open the table is read every
+* `intervalMs`, its rows taken out of it and sent to the channels of their records, as the server, under the channel's
+* broadcast rate. A send nobody hears is dropped, as is one the checks refuse. With several processes, one takes a row
+* and the relay carries it to the others.
+*/
+const databaseSends = ({ db, statementTimeoutMs, registry, broadcasts, intervalMs = 1e3, report }) => {
+	const read = async () => {
+		for (;;) {
+			const rows = await takeSends(db, statementTimeoutMs);
+			for (const row of rows) {
+				const publication = publicationOfSend(registry, row);
+				if (publication) await broadcasts.publish([publication]);
+			}
+			if (rows.length < batchSize) return;
+		}
+	};
+	return followedPoll(read, intervalMs, report);
+};
+//#endregion
+export { databaseSends, publicationOfSend };

package/dist/channels/sends-prune.js

@@ -0,0 +1,15 @@
+import { writeTransaction } from "../transactions.js";
+import { sendsSchema } from "./sends-schema-sql.js";
+import { inBatches, pruneBatchSize } from "../realtime/broadcast-prune.js";
+import { sql } from "kysely";
+//#region src/channels/sends-prune.ts
+const deleteOldSends = (db, statementTimeoutMs, limit) => writeTransaction(db, statementTimeoutMs, async (trx) => {
+	const { numAffectedRows } = await sql`delete from ${sql.id(sendsSchema, "sends")} where id in (
+        select id from ${sql.id(sendsSchema, "sends")} where sent_at < now() - interval '48 hours' limit ${limit} for update skip locked
+      )`.execute(trx);
+	return Number(numAffectedRows ?? 0n);
+});
+/** Deletes the sends of `channels.sends` more than 48 hours old, which no reader took because no socket was open, in batches. */
+const pruneSends = (db, statementTimeoutMs) => inBatches(pruneBatchSize, (limit) => deleteOldSends(db, statementTimeoutMs, limit));
+//#endregion
+export { pruneSends };

package/dist/channels/sends-schema-sql.js

@@ -0,0 +1,30 @@
+//#region src/channels/sends-schema-sql.ts
+/** The schema of SQL's broadcasts to the record channels. */
+const sendsSchema = "channels";
+/**
+* - `sends`: each broadcast SQL sent, inserted in the sender's transaction, taken out by a serving process once
+*   committed, or pruned after 48 hours when none read it.
+* - `send(resource, key, event, payload)`: inserts one. It runs as its owner, the app's role, which alone may call it,
+*   so that no other role, such as one of `/api/sb/rest/v1`'s, sends as the server; a trigger function that sends for
+*   them is `security definer`.
+*/
+const sendsSchemaSql = `create schema if not exists ${sendsSchema};
+
+create table if not exists ${sendsSchema}.sends (
+  id bigint generated always as identity primary key,
+  resource text not null,
+  key text not null,
+  event text not null,
+  payload jsonb not null,
+  sent_at timestamptz not null default now()
+);
+
+create index if not exists sends_sent_at on ${sendsSchema}.sends (sent_at);
+
+create or replace function ${sendsSchema}.send(resource text, key text, event text, payload jsonb) returns void
+  language sql security definer set search_path = ''
+  as $$ insert into ${sendsSchema}.sends (resource, key, event, payload) values (send.resource, send.key, send.event, send.payload) $$;
+
+revoke execute on function ${sendsSchema}.send(text, text, text, jsonb) from public;`;
+//#endregion
+export { sendsSchema, sendsSchemaSql };

package/dist/channels/sends-schema.d.ts

@@ -0,0 +1,7 @@
+import { Db } from "@protobase/query";
+//#region src/channels/sends-schema.d.ts
+/** The SQL that adds the `channels` schema `realtime: { sqlSends: true }` needs; `undefined` when it is there. */
+export declare const channelSendsMigration: (db: Db) => Promise<"create schema if not exists channels;\n\ncreate table if not exists channels.sends (\n  id bigint generated always as identity primary key,\n  resource text not null,\n  key text not null,\n  event text not null,\n  payload jsonb not null,\n  sent_at timestamptz not null default now()\n);\n\ncreate index if not exists sends_sent_at on channels.sends (sent_at);\n\ncreate or replace function channels.send(resource text, key text, event text, payload jsonb) returns void\n  language sql security definer set search_path = ''\n  as $$ insert into channels.sends (resource, key, event, payload) values (send.resource, send.key, send.event, send.payload) $$;\n\nrevoke execute on function channels.send(text, text, text, jsonb) from public;" | undefined>;
+/** Refuses to go on while the `channels` schema is missing; the project's migrations add it. */
+export declare const checkChannelSends: (db: Db) => Promise<void>;
+//#endregion

package/dist/channels/sends-schema.js

@@ -0,0 +1,18 @@
+import { sendsSchema, sendsSchemaSql } from "./sends-schema-sql.js";
+import { migrationCommand } from "../changes/capture-schema.js";
+import { sql } from "kysely";
+//#region src/channels/sends-schema.ts
+const sendsCurrent = async (db) => {
+	const { rows } = await sql`select to_regclass(${`${sendsSchema}.sends`}) is not null
+    and to_regprocedure(${`${sendsSchema}.send(text, text, text, jsonb)`}) is not null as found`.execute(db);
+	return rows[0].found;
+};
+/** The SQL that adds the `channels` schema `realtime: { sqlSends: true }` needs; `undefined` when it is there. */
+const channelSendsMigration = async (db) => await sendsCurrent(db) ? void 0 : sendsSchemaSql;
+/** Refuses to go on while the `channels` schema is missing; the project's migrations add it. */
+const checkChannelSends = async (db) => {
+	if (await sendsCurrent(db)) return;
+	throw new Error(`The ${sendsSchema} schema that realtime.sqlSends needs is missing. Write it as a migration with \`${migrationCommand}\`, apply it with the project's migrations, then start again.`);
+};
+//#endregion
+export { channelSendsMigration, checkChannelSends };

package/dist/channels/sent.js

@@ -1,8 +1,24 @@
+import { decodeBinaryFrame, encodeBinaryFrame } from "./binary-frame.js";
 //#region src/channels/sent.ts
 /** The sender as a broadcast message names it. */
 const senderOf = (sent) => ({
 	user: sent.user,
 	...sent.server && { server: true }
 });
+/**
+* A broadcast as the hub's payload. One of bytes goes as one binary frame, its sender the header, since the relay
+* carries a payload of bytes as they are and any other as JSON, which has no bytes.
+*/
+const packSent = (sent) => sent.payload instanceof ArrayBuffer ? encodeBinaryFrame(senderOf(sent), sent.payload) : sent;
+/** The broadcast a hub's payload carries (`packSent`). */
+const unpackSent = (packed) => {
+	if (!(packed instanceof ArrayBuffer)) return packed;
+	const { header, bytes } = decodeBinaryFrame(packed);
+	return {
+		user: header.user,
+		...header.server === true && { server: true },
+		payload: bytes
+	};
+};
 //#endregion
-export { senderOf };
+export { packSent, senderOf, unpackSent };

package/dist/create-admin.d.ts

@@ -10,6 +10,7 @@ import { HistoryOptions } from "./history/options.js";
 import { WebhooksOptions } from "./webhooks/table/options.js";
 import { NotificationsOptions } from "./notifications/options.js";
 import { CallsOptions } from "./calls/calls-options.js";
+import { StatusOptions } from "./status/options.js";
 import { SubscriptionDefinition } from "./webhooks/subscription.js";
 import { FilesOptions } from "./files/options.js";
 import { Difficulty } from "./forms/challenge.js";
@@ -51,10 +52,12 @@ export type CreateAdminInput = {
   subscriptions?: SubscriptionDefinition[];
   /** Webhook subscriptions made in the admin app, from `webhooks: {}` (see `WebhooksOptions`). */
   webhooks?: WebhooksOptions;
-  /** How `/api/sb/realtime/v1` is served: by one process or several (see `RealtimeOptions`). */
+  /** How `/api/sb/realtime/v1` and `/api/channels` are served: by one process or several, and whether SQL sends to channels (see `RealtimeOptions`). */
   realtime?: RealtimeOptions;
   /** Each user's devices and the endpoints that register them, from `notifications: {}` (see `NotificationsOptions`). */
   notifications?: NotificationsOptions;
+  /** People's own status, from `status: {}` (see `StatusOptions`): it needs `auth` with organizations. */
+  status?: StatusOptions;
   /** The media server behind the calls functions admit members to with `calls.join` (see `CallsOptions`). */
   calls?: CallsOptions;
   /**
@@ -96,5 +99,5 @@ export type CreateAdminInput = {
   upgradeWebSocket?: UpgradeWebSocket;
 };
 /** The admin REST API as a Hono app. It uses only Web APIs, so it runs on Node, Workers and anywhere else Hono does. */
-export declare const createAdmin: ({ resources: appResources, views: appViews, pages, userMenu, bottomBars, db, authenticate, auth, functions, secret, files: filesOptions, events, history: historyOptions, jobs, subscriptions, webhooks: webhooksOptions, realtime, notifications, calls, mobile, app: identity, icons, bundlePlugins, fieldTypes, options, formsDifficulty, commentUsers: givenCommentUsers, verifyToken, upgradeWebSocket }: CreateAdminInput) => Admin;
+export declare const createAdmin: ({ resources: appResources, views: appViews, pages, userMenu, bottomBars, db, authenticate, auth, functions, secret, files: filesOptions, events, history: historyOptions, jobs, subscriptions, webhooks: webhooksOptions, realtime, notifications, status, calls, mobile, app: identity, icons, bundlePlugins, fieldTypes, options, formsDifficulty, commentUsers: givenCommentUsers, verifyToken, upgradeWebSocket }: CreateAdminInput) => Admin;
 //#endregion

package/dist/create-admin.js

@@ -17,10 +17,11 @@ import { apiKeySettings } from "./api-keys/api-key-settings.js";
 import { apiKeyCaller } from "./api-keys/resolve-caller.js";
 import { jwtVerifier } from "./auth/jwt.js";
 import { realtimeApp } from "./realtime/realtime-app.js";
-import { relayed } from "./realtime/relay/realtime-options.js";
+import { relayed, sqlSends } from "./realtime/relay/realtime-options.js";
 import { realtimeHubs } from "./realtime/realtime-hubs.js";
 import { channelSender } from "./channels/channel-sender.js";
 import { channelRoutes } from "./channels/channel-routes.js";
+import { databaseSends } from "./channels/database-sends.js";
 import { startRealtimePrune } from "./realtime/realtime-prune.js";
 import { restRoutes } from "./rest/rest-routes.js";
 import { storageRoutes } from "./storage/storage-routes.js";
@@ -65,6 +66,10 @@ import { historyRoutes } from "./notifications/history-routes.js";
 import { deviceRoutes } from "./notifications/routes.js";
 import { notificationSenders, webPushKey } from "./notifications/senders-of.js";
 import { pushJob } from "./notifications/push-job.js";
+import { onDoNotDisturb } from "./status/do-not-disturb.js";
+import { checkStatusAuth, statusNames } from "./status/options.js";
+import { statusRoutes } from "./status/routes.js";
+import { storeSchema } from "./better-auth/store/store-names.js";
 import { liveSessions } from "./better-auth/live-sessions.js";
 import { checkBottomBars, checkShell } from "./check-shell.js";
 import { checkOwnerFields } from "./check-owners.js";
@@ -105,13 +110,14 @@ import { createScanGuard } from "./scan-guard.js";
 import { failedJobs, failedJobsView } from "./jobs/failed-jobs.js";
 import { Hono } from "hono";
 import { accountPage, accountPageName, checkPages, settingsResources, withSettingsFields } from "@protobase/layout";
+import { statusPath } from "@protobase/schema/internal";
 //#region src/create-admin.ts
 const declaredRoles = (auth, roles) => {
 	const names = [...auth?.roles ?? [], ...Object.keys(roles?.definitions ?? {})];
 	return names.length > 0 ? [...new Set(names)] : void 0;
 };
 /** The admin REST API as a Hono app. It uses only Web APIs, so it runs on Node, Workers and anywhere else Hono does. */
-const createAdmin = ({ resources: appResources, views: appViews = [], pages = [], userMenu, bottomBars = [], db, authenticate, auth, functions = {}, secret, files: filesOptions, events, history: historyOptions, jobs = [], subscriptions = [], webhooks: webhooksOptions, realtime, notifications, calls, mobile, app: identity, icons, bundlePlugins = [], fieldTypes = {}, options = {}, formsDifficulty, commentUsers: givenCommentUsers, verifyToken, upgradeWebSocket }) => {
+const createAdmin = ({ resources: appResources, views: appViews = [], pages = [], userMenu, bottomBars = [], db, authenticate, auth, functions = {}, secret, files: filesOptions, events, history: historyOptions, jobs = [], subscriptions = [], webhooks: webhooksOptions, realtime, notifications, status, calls, mobile, app: identity, icons, bundlePlugins = [], fieldTypes = {}, options = {}, formsDifficulty, commentUsers: givenCommentUsers, verifyToken, upgradeWebSocket }) => {
 	const basePath = options.basePath ?? "/api/v1";
 	const appModels = appResources.map((resource) => resource.toModel());
 	const withComments = appModels.some((model) => model.comments);
@@ -172,6 +178,14 @@ const createAdmin = ({ resources: appResources, views: appViews = [], pages = []
 	const errorReporting = errorReportingSettings(options.errorReporting, globalThis.process?.env ?? {});
 	const maps = mapSettings(options.maps, globalThis.process?.env ?? {});
 	const senders = notifications ? notificationSenders(notifications) : [];
+	if (status) checkStatusAuth(auth);
+	const statusTables = status && auth && {
+		statuses: statusNames(status),
+		members: {
+			schema: storeSchema(auth),
+			table: "member"
+		}
+	};
 	const pushKey = webPushKey(senders);
 	const locale = localeSetting(options.locale);
 	const plugins = pluginOptions(options.plugins, globalThis.process?.env ?? {}, bundlePlugins);
@@ -230,6 +244,7 @@ const createAdmin = ({ resources: appResources, views: appViews = [], pages = []
 		...maps && { maps },
 		...notifications && notifications.ui !== false && { bell: true },
 		...pushKey && { webPushKey: pushKey },
+		...statusTables && { status: true },
 		...locale && { locale },
 		plugins,
 		sources,
@@ -399,6 +414,18 @@ const createAdmin = ({ resources: appResources, views: appViews = [], pages = []
 	}));
 	if (upgradeWebSocket) {
 		const visitors = (caller) => withAnonymous(caller, options.roles);
+		const sends = sqlSends(realtime) ? databaseSends({
+			db,
+			statementTimeoutMs: deps.statementTimeoutMs,
+			registry,
+			broadcasts: hubs.records.broadcasts,
+			report
+		}) : void 0;
+		const follow = () => {
+			const unrelay = hubs.follow();
+			const unsend = sends?.follow();
+			return () => (unsend?.(), unrelay());
+		};
 		app.route(systemPath || "/", channelRoutes({
 			deps,
 			upgradeWebSocket,
@@ -406,7 +433,7 @@ const createAdmin = ({ resources: appResources, views: appViews = [], pages = []
 			authenticateUpgrade: visitors(upgradeAuthenticate),
 			onError,
 			hubs: hubs.records,
-			follow: hubs.follow,
+			follow,
 			report
 		}));
 	}
@@ -431,6 +458,7 @@ const createAdmin = ({ resources: appResources, views: appViews = [], pages = []
 		if (auth) removeHistoryWithUsers(auth, history);
 		app.route(historyPath(systemPath), guarded((routes) => void routes.route("/", historyRoutes(history, auth?.origins ?? []))));
 	}
+	if (statusTables) app.route(statusPath(systemPath), guarded((routes) => void routes.route("/", statusRoutes(db, statusTables))));
 	if (forms) app.route(`${systemPath}/forms`, formRoutes(deps, forms));
 	const feed = tableFeed({
 		db,
@@ -490,6 +518,7 @@ const createAdmin = ({ resources: appResources, views: appViews = [], pages = []
 		db,
 		statementTimeoutMs: deps.statementTimeoutMs,
 		relayed: relayed(realtime),
+		sqlSends: sqlSends(realtime),
 		report
 	});
 	return Object.assign(app, {
@@ -500,7 +529,7 @@ const createAdmin = ({ resources: appResources, views: appViews = [], pages = []
 			...withHistory && days !== void 0 ? [pruneHistoryJob(changes, days)] : [],
 			...mentions ? [mentions] : [],
 			...fill ? [fill] : [],
-			...notifications ? [pushJob(notifications, senders, auth && liveSessions(auth))] : []
+			...notifications ? [pushJob(notifications, senders, auth && liveSessions(auth), statusTables ? (jobDb, userIds) => onDoNotDisturb(jobDb, statusTables.statuses, userIds) : void 0)] : []
 		]
 	});
 };

package/dist/deps.d.ts

@@ -53,6 +53,8 @@ export type Deps = {
   maps?: MapSettings;
   /** Whether the shell draws the notification bell: notifications are on and their `ui` is not false. */
   bell?: boolean;
+  /** Whether people set their own status (`status: {}`), which `/meta` names to everyone. */
+  status?: boolean;
   /** The VAPID public key browsers subscribe for Web Push with, when notifications have a web sender, which `/meta` names to everyone. */
   webPushKey?: string;
   /** The language the admin app's screens are in for everyone, which `/meta` names to everyone. */