@protobase/server 0.59.2 → 0.60.0

package/dist/meta.js

@@ -97,6 +97,7 @@ const createMeta = (deps, appName, appIcon) => {
 				...deps.bell && { bell: true },
 				...deps.webPushKey && { webPushKey: deps.webPushKey }
 			} },
+			...deps.status && { status: true },
 			...deps.locale && { locale: deps.locale },
 			...deps.files && deps.files.trustedHosts.length > 0 && { files: { trustedHosts: deps.files.trustedHosts } },
 			...plugins.length > 0 && { plugins },

package/dist/notifications/caller.js

@@ -5,8 +5,8 @@ import { forbidden } from "../problem.js";
 * Refused: visitors, outside apps acting for the user (an MCP client), and every session whose authenticator does not
 * mark it as the user's own sign-in (`Session.signIn`), staff signed in as the user included.
 */
-const ownSignInUser = (session) => {
-	const refuse = () => forbidden("own-sign-in-only", "Only someone signed in as themselves can reach their devices and notifications");
+const ownSignInUser = (session, what = "reach their devices and notifications") => {
+	const refuse = () => forbidden("own-sign-in-only", `Only someone signed in as themselves can ${what}`);
 	if (session.anonymous || session.client || session.signIn?.staff !== false) throw refuse();
 	const userId = String(session.user.id);
 	if (userId === "" || session.user.id === void 0 || session.user.id === null) throw refuse();

package/dist/notifications/deliver.js

@@ -16,7 +16,8 @@ const listed = (counts) => [...counts].map(([method, count]) => `${count} in ${m
 * One try of a send, resuming from `given`: for a user send, each user's history entry when the send is for the inbox
 * (once, as `record` marks it), then the user's devices as the store lists them now; for a device send, the devices
 * with those ids now. A device the store gives that is not the user's, or not one asked for, gets nothing. With
-* `liveSessions`, a device whose session no longer stands is removed instead of pushed to. Each kind's
+* `liveSessions`, a device whose session no longer stands is removed instead of pushed to; with `quiet`, a device of a
+* user on do not disturb gets nothing, now or on a later try, though the history keeps the entry. Each kind's
 * devices go to its sender in one batch; a kind without a sender is skipped. An answer of `gone` removes the device,
 * `retry` leaves it to the next try once and gives up on it the second time, and any other is done. A sender that
 * throws leaves its batch to the next try. The try then throws, counting what is left, so the job retries it, or
@@ -70,8 +71,19 @@ const deliver = async ({ to, message }, given, steps) => {
 		}
 		return pending.filter(stands);
 	};
+	const undisturbed = async (devices) => {
+		const { quiet } = steps;
+		const pending = devices.filter((device) => !done.has(device.id));
+		if (!quiet || pending.length === 0) return pending;
+		const held = await quiet([...new Set(pending.map((device) => device.userId))]);
+		const kept = pending.filter((device) => !held.has(device.userId));
+		if (kept.length === pending.length) return kept;
+		for (const device of pending.filter((device) => held.has(device.userId))) markDone(device.id);
+		await steps.save(progress);
+		return kept;
+	};
 	const push = async (given) => {
-		const devices = await standing(given);
+		const devices = await undisturbed(await standing(given));
 		for (const device of devices) if (!steps.senders.some((sender) => sender.kinds.includes(device.kind))) markDone(device.id);
 		for (const sender of steps.senders) {
 			const batch = devices.filter((device) => sender.kinds.includes(device.kind) && !done.has(device.id));

package/dist/notifications/push-job.js

@@ -26,11 +26,12 @@ const recordOnce = (db, options, job) => async (userId, entry, progress) => {
 };
 /**
 * The job that delivers what `sendNotification` sends, through `senders` (guarded, see `notificationSenders`) and the
-* stores `options` configure; with `liveSessions`, as with Protobase's auth, only to devices whose session stands. A
+* stores `options` configure; with `liveSessions`, as with Protobase's auth, only to devices whose session stands, and
+* with `quiet`, as with `status`, to no device of a user on do not disturb. A
 * try resumes where the last one stopped (see `deliver`); once delivered, the job keeps no message. A few tries only: a
 * device that keeps asking for a retry is given up on the second time.
 */
-const pushJob = (options, senders, liveSessions) => defineJob({
+const pushJob = (options, senders, liveSessions, quiet) => defineJob({
 	name: pushJobName,
 	payload: pushPayload,
 	maxAttempts: 5,
@@ -44,7 +45,8 @@ const pushJob = (options, senders, liveSessions) => defineJob({
 			save: (progress) => saveJobProgress(db, job, progress),
 			hold: () => holdJob(db, job),
 			complete: () => replaceJobData(db, job, { complete: true }),
-			...liveSessions && { liveSessions }
+			...liveSessions && { liveSessions },
+			...quiet && { quiet: (userIds) => quiet(db, userIds) }
 		});
 	}
 });

package/dist/notifications/schema.js

@@ -1,7 +1,7 @@
 import { migrationCommand } from "../changes/capture-schema.js";
 import { historyNames, notificationsNames } from "./options.js";
-import { storeSchema } from "../better-auth/store/store-names.js";
 import { deviceSessionColumnSql, devicesTableSql, qualified } from "./schema-sql.js";
+import { storeSchema } from "../better-auth/store/store-names.js";
 import { historyTableSql } from "./history-sql.js";
 import { sql } from "kysely";
 //#region src/notifications/schema.ts
@@ -11,9 +11,12 @@ const authUsersTable = (auth) => ({
 	table: auth.options.user?.modelName ?? "user"
 });
 const regclass = async (db, name) => (await sql`select to_regclass(${name})::oid as oid`.execute(db)).rows[0].oid;
-const userIdType = async (db, users) => {
+const userIdType = async (db, users, of = {
+	feature: "notifications",
+	rows: "devices"
+}) => {
 	const oid = await regclass(db, qualified(users));
-	if (oid === null) throw new Error(`notifications: auth's users table ${qualified(users)} is not in the app's database, so devices cannot point at it`);
+	if (oid === null) throw new Error(`${of.feature}: auth's users table ${qualified(users)} is not in the app's database, so ${of.rows} cannot point at it`);
 	const { rows } = await sql`select format_type(atttypid, atttypmod) as type from pg_attribute where attrelid = ${oid} and attname = 'id'`.execute(db);
 	return rows[0].type;
 };
@@ -89,4 +92,4 @@ const checkNotificationsSchema = async (db, options = {}, auth) => {
 	await checkHistoryTable(db, options, users);
 };
 //#endregion
-export { authUsersTable, checkNotificationsSchema, notificationsMigration };
+export { authUsersTable, checkNotificationsSchema, notificationsMigration, regclass, userIdType };

package/dist/package.js

@@ -1,4 +1,4 @@
 //#region package.json
-var version = "0.59.2";
+var version = "0.60.0";
 //#endregion
 export { version };

package/dist/routes/record.js

@@ -13,6 +13,7 @@ import { revealField } from "../reveal-service.js";
 import { readHistory } from "../history/read-history.js";
 import { mentionable } from "../comments/mentionable.js";
 import { generateField } from "../ai/generate-route.js";
+import { readRecordCalls, watchRecordCalls } from "../calls/record-calls.js";
 import { Hono } from "hono";
 //#region src/routes/record.ts
 const recordRoutes = (deps) => {
@@ -21,6 +22,11 @@ const recordRoutes = (deps) => {
 		const { entry } = resolveTarget(deps, c.req.param("resource"));
 		if (c.req.param("key").endsWith(":history")) return c.json(await readHistory(deps, entry, c.get("session"), keyFromPath(c, entry, ":history"), c.req.query()));
 		if (c.req.param("key").endsWith(":comments")) return c.json(await readComments(deps, entry, c.get("session"), keyFromPath(c, entry, ":comments"), c.req.query()));
+		if (c.req.param("key").endsWith(":calls")) {
+			const key = keyFromPath(c, entry, ":calls");
+			if (c.req.query("watch") === "true") return watchRecordCalls(c, deps, entry, key);
+			return c.json(await readRecordCalls(deps, entry, c.get("session"), key));
+		}
 		if (c.req.param("key").endsWith(":mentionable")) return c.json(await mentionable(deps, entry, c.get("session"), keyFromPath(c, entry, ":mentionable"), c.req.query()));
 		const found = await readRecord(deps, entry, c.get("session"), keyFromPath(c, entry), c.req.query("show_deleted") === "true");
 		const columns = selectedFields({

package/dist/status/do-not-disturb.d.ts

@@ -0,0 +1,9 @@
+import { StatusNames } from "./options.js";
+import { Db } from "@protobase/query";
+//#region src/status/do-not-disturb.d.ts
+/**
+ * Which of these people are on do not disturb now: their status says so and its clear time, if any, is still to come.
+ * The one check of everything that would alert someone, such as a push, so each holds it alike.
+ */
+export declare const onDoNotDisturb: (db: Db, names: StatusNames, userIds: readonly string[]) => Promise<Set<string>>;
+//#endregion

package/dist/status/do-not-disturb.js

@@ -0,0 +1,15 @@
+import { qualified } from "../notifications/schema-sql.js";
+import { sql } from "kysely";
+//#region src/status/do-not-disturb.ts
+/**
+* Which of these people are on do not disturb now: their status says so and its clear time, if any, is still to come.
+* The one check of everything that would alert someone, such as a push, so each holds it alike.
+*/
+const onDoNotDisturb = async (db, names, userIds) => {
+	if (userIds.length === 0) return /* @__PURE__ */ new Set();
+	const { rows } = await sql`select user_id from ${sql.raw(qualified(names))}
+    where user_id in (${sql.join([...new Set(userIds)])}) and availability = 'do_not_disturb' and (clears_at is null or clears_at > now())`.execute(db);
+	return new Set(rows.map((row) => String(row.user_id)));
+};
+//#endregion
+export { onDoNotDisturb };

package/dist/status/options.d.ts

@@ -0,0 +1,15 @@
+//#region src/status/options.d.ts
+/** People's own status, turned on with `status: {}` in `protobase.config.ts`; it needs auth with organizations. */
+export type StatusOptions = {
+  /** The schema of the statuses table; default `status`. */
+  schema?: string;
+};
+/** The statuses table's names, checked: a bad schema name is an error naming the option. */
+export declare const statusNames: (options?: StatusOptions) => {
+  schema: string;
+  table: string;
+};
+export type StatusNames = ReturnType<typeof statusNames>;
+/** The options, checked as `status` takes them. */
+export declare const checkStatusOptions: (options: StatusOptions) => StatusOptions;
+//#endregion

package/dist/status/options.js

@@ -0,0 +1,25 @@
+//#region src/status/options.ts
+const namePattern = /^[a-z_][a-z0-9_]*$/;
+const maxNameBytes = 63;
+/** The statuses table's names, checked: a bad schema name is an error naming the option. */
+const statusNames = (options = {}) => {
+	const schema = options.schema ?? "status";
+	if (typeof schema !== "string" || !namePattern.test(schema) || Buffer.byteLength(schema) > maxNameBytes) throw new Error(`status schema is not a valid name: use lowercase letters, digits and "_", at most ${maxNameBytes} characters`);
+	return {
+		schema,
+		table: "statuses"
+	};
+};
+/** The options, checked as `status` takes them. */
+const checkStatusOptions = (options) => {
+	const unknown = Object.keys(options).find((key) => key !== "schema");
+	if (unknown !== void 0) throw new Error(`status takes no option "${unknown}": only schema`);
+	statusNames(options);
+	return options;
+};
+/** Status shows people to the members of their organizations, so an app without organizations cannot turn it on. */
+const checkStatusAuth = (auth) => {
+	if (!auth?.organizations) throw new Error("status: {} shows people to the members of their organizations: turn organizations on in the auth config, or remove status");
+};
+//#endregion
+export { checkStatusAuth, checkStatusOptions, statusNames };

package/dist/status/routes.js

@@ -0,0 +1,38 @@
+import { ownSignInUser } from "../notifications/caller.js";
+import { jsonBody, jsonOnly, limitedBody } from "../notifications/history-request.js";
+import { statusInput } from "./status-input.js";
+import { clearStatus, ownStatus, setStatus, visibleStatuses } from "./status-store.js";
+import { Hono } from "hono";
+//#region src/status/routes.ts
+const noStore = { "Cache-Control": "no-store" };
+const viewerOf = (session) => session.anonymous || session.client ? void 0 : String(session.user.id);
+/**
+* The status endpoints, mounted at `statusPath` behind the API's authenticator: `GET /` the caller's own status,
+* `PUT /` sets it, `DELETE /` clears it, and `GET /people` the statuses of everyone who shares an organization with
+* the caller. No request names whose status it sets: the person comes from the session alone, and only someone
+* signed in as themselves sets theirs, never staff signed in as them (see `ownSignInUser`).
+*/
+const statusRoutes = (db, tables) => {
+	const app = new Hono();
+	app.get("/", async (c) => {
+		const viewer = viewerOf(c.get("session"));
+		const status = viewer === void 0 ? void 0 : await ownStatus(db, tables, viewer);
+		return c.json({ status: status ?? null }, 200, noStore);
+	});
+	app.put("/", jsonOnly, limitedBody, async (c) => {
+		const userId = ownSignInUser(c.get("session"), "set their status");
+		await setStatus(db, tables, userId, statusInput(await jsonBody(c)));
+		return c.json({ status: await ownStatus(db, tables, userId) ?? null }, 200, noStore);
+	});
+	app.delete("/", async (c) => {
+		await clearStatus(db, tables, ownSignInUser(c.get("session"), "set their status"));
+		return c.body(null, 204);
+	});
+	app.get("/people", async (c) => {
+		const viewer = viewerOf(c.get("session"));
+		return c.json({ statuses: viewer === void 0 ? [] : await visibleStatuses(db, tables, viewer) }, 200, noStore);
+	});
+	return app;
+};
+//#endregion
+export { statusRoutes };

package/dist/status/schema-sql.js

@@ -0,0 +1,19 @@
+import { quoteIdent } from "../changes/capture-sql.js";
+import { qualified } from "../notifications/schema-sql.js";
+//#region src/status/schema-sql.ts
+/**
+* The statuses table: one row per person who set a status, which goes with the user. A custom text or a clear time
+* not set is NULL, and nothing has a default. Clearing a status deletes its row.
+*/
+const statusesTableSql = ({ schema, table }, user) => [`create schema if not exists ${quoteIdent(schema)}`, `create table ${qualified({
+	schema,
+	table
+})} (
+  user_id ${user.type} primary key references ${user.references} on delete cascade,
+  availability text not null check (availability in ('automatic', 'busy', 'do_not_disturb')),
+  text text check (char_length(text) between 1 and 100),
+  clears_at timestamptz,
+  updated_at timestamptz not null
+)`];
+//#endregion
+export { statusesTableSql };

package/dist/status/schema.d.ts

@@ -0,0 +1,12 @@
+import { StatusOptions } from "./options.js";
+import { AdminAuth } from "../better-auth/create-auth.js";
+import { Db } from "@protobase/query";
+//#region src/status/schema.d.ts
+/**
+ * The SQL that adds the statuses table `status` keeps people's statuses in, its user column pointing at auth's users
+ * table; `undefined` when it exists. An app without organizations is refused (see `checkStatusAuth`).
+ */
+export declare const statusMigration: (db: Db, options: StatusOptions, auth: AdminAuth | undefined) => Promise<string | undefined>;
+/** Refuses to start while the statuses table is missing, or the app has no organizations. */
+export declare const checkStatusSchema: (db: Db, options: StatusOptions, auth: AdminAuth | undefined) => Promise<void>;
+//#endregion

package/dist/status/schema.js

@@ -0,0 +1,33 @@
+import { migrationCommand } from "../changes/capture-schema.js";
+import { qualified } from "../notifications/schema-sql.js";
+import { checkStatusAuth, statusNames } from "./options.js";
+import { authUsersTable, regclass, userIdType } from "../notifications/schema.js";
+import { statusesTableSql } from "./schema-sql.js";
+//#region src/status/schema.ts
+/**
+* The SQL that adds the statuses table `status` keeps people's statuses in, its user column pointing at auth's users
+* table; `undefined` when it exists. An app without organizations is refused (see `checkStatusAuth`).
+*/
+const statusMigration = async (db, options, auth) => {
+	checkStatusAuth(auth);
+	const names = statusNames(options);
+	if (await regclass(db, qualified(names)) !== null) return;
+	const users = authUsersTable(auth);
+	const type = await userIdType(db, users, {
+		feature: "status",
+		rows: "statuses"
+	});
+	return `${statusesTableSql(names, {
+		type,
+		references: `${qualified(users)} (id)`
+	}).join(";\n\n")};`;
+};
+/** Refuses to start while the statuses table is missing, or the app has no organizations. */
+const checkStatusSchema = async (db, options, auth) => {
+	checkStatusAuth(auth);
+	const table = qualified(statusNames(options));
+	if (await regclass(db, table) !== null) return;
+	throw new Error(`The statuses table ${table} of status is missing. Write it as a migration with \`${migrationCommand}\`, apply it with the project's migrations, then start again.`);
+};
+//#endregion
+export { checkStatusSchema, statusMigration };

package/dist/status/status-input.js

@@ -0,0 +1,33 @@
+import { badRequest } from "../problem.js";
+import { availabilities, statusTextProblem } from "@protobase/schema/internal";
+import { z } from "zod";
+//#region src/status/status-input.ts
+const body = z.strictObject({
+	availability: z.enum(availabilities),
+	text: z.string().nullable(),
+	clearsAt: z.iso.datetime({ offset: true }).nullable()
+});
+/**
+* The status a request sets, checked: an availability, a one-line text of at most `maxStatusText` characters, kept
+* trimmed, an empty one as none, and a clear time to come or `null` for never. Anything else, a user named in it
+* too, is a 400 that says what is wrong.
+*/
+const statusInput = (given, now = /* @__PURE__ */ new Date()) => {
+	const parsed = body.safeParse(given);
+	if (!parsed.success) {
+		const issue = parsed.error.issues[0];
+		throw badRequest("invalid-status", `Send { availability, text, clearsAt }: ${issue.path.join(".") || "the body"} ${issue.message.toLowerCase()}`);
+	}
+	const { availability, clearsAt } = parsed.data;
+	const text = parsed.data.text?.trim() || null;
+	const problem = text === null ? void 0 : statusTextProblem(text);
+	if (problem) throw badRequest("invalid-status-text", problem);
+	if (clearsAt !== null && Date.parse(clearsAt) <= now.getTime()) throw badRequest("invalid-clear-time", "A status clears at a time still to come, or never");
+	return {
+		availability,
+		text,
+		clearsAt: clearsAt === null ? null : new Date(clearsAt).toISOString()
+	};
+};
+//#endregion
+export { statusInput };

package/dist/status/status-store.js

@@ -0,0 +1,39 @@
+import { qualified } from "../notifications/schema-sql.js";
+import { sql } from "kysely";
+//#region src/status/status-store.ts
+const statusOf = (row) => ({
+	userId: String(row.user_id),
+	availability: row.availability,
+	text: row.text,
+	clearsAt: row.clears_at?.toISOString() ?? null
+});
+const holds = sql`(clears_at is null or clears_at > now())`;
+/** The person's own status, as it holds now; `undefined` when they have none. */
+const ownStatus = async (db, tables, userId) => {
+	const statuses = sql.raw(qualified(tables.statuses));
+	const { rows } = await sql`select user_id, availability, text, clears_at from ${statuses} where user_id = ${userId} and ${holds}`.execute(db);
+	return rows[0] && statusOf(rows[0]);
+};
+/** The statuses that hold now of everyone who shares an organization with `viewerId`, their own included when they have one. */
+const visibleStatuses = async (db, tables, viewerId) => {
+	const statuses = sql.raw(qualified(tables.statuses));
+	const members = sql.raw(qualified(tables.members));
+	const { rows } = await sql`select s.user_id, s.availability, s.text, s.clears_at from ${statuses} s
+    where ${holds} and exists (select from ${members} own join ${members} other on other.organization_id = own.organization_id
+      where own.user_id = ${viewerId} and other.user_id = s.user_id)
+    order by s.user_id`.execute(db);
+	return rows.map(statusOf);
+};
+/** Sets the person's status, replacing the one they had; one that says nothing, automatic without a text, clears it. */
+const setStatus = async (db, tables, userId, input) => {
+	if (input.availability === "automatic" && input.text === null) return clearStatus(db, tables, userId);
+	const statuses = sql.raw(qualified(tables.statuses));
+	await sql`insert into ${statuses} (user_id, availability, text, clears_at, updated_at) values (${userId}, ${input.availability}, ${input.text}, ${input.clearsAt}, now())
+    on conflict (user_id) do update set availability = excluded.availability, text = excluded.text, clears_at = excluded.clears_at, updated_at = excluded.updated_at`.execute(db);
+};
+/** Clears the person's status, whether or not they had one. */
+const clearStatus = async (db, tables, userId) => {
+	await sql`delete from ${sql.raw(qualified(tables.statuses))} where user_id = ${userId}`.execute(db);
+};
+//#endregion
+export { clearStatus, ownStatus, setStatus, visibleStatuses };

package/dist/webhooks/attempt.js

@@ -47,6 +47,7 @@ const callFunction = async (name, subscription, event, options, context, signal)
 		session,
 		records: context.records(session)
 	};
+	const noCalls = () => Promise.reject(/* @__PURE__ */ new Error(`The function "${name}" reached calls, which a webhook delivery has none of`));
 	const acceptWebSocket = () => {
 		throw new Error(`The function "${name}" accepted a WebSocket, but a webhook delivery is no upgrade`);
 	};
@@ -56,7 +57,11 @@ const callFunction = async (name, subscription, event, options, context, signal)
 		channels: context.channels,
 		caller: async () => caller,
 		acceptWebSocket,
-		calls: { join: async () => acceptWebSocket() }
+		calls: {
+			join: async () => acceptWebSocket(),
+			remove: noCalls,
+			of: noCalls
+		}
 	};
 	return invokeFunction(name, fn, await request("http://protobase.internal/", event, options, signal), fn.options.public ? functionContext : {
 		...functionContext,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@protobase/server",
-  "version": "0.59.2",
+  "version": "0.60.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.59.2",
-    "@protobase/query": "0.59.2",
-    "@protobase/schema": "0.59.2",
+    "@protobase/layout": "0.60.0",
+    "@protobase/query": "0.60.0",
+    "@protobase/schema": "0.60.0",
     "@react-email/render": "^2.1.0",
     "@scalar/hono-api-reference": "^0.12.10",
     "@sentry/core": "^11.7.0",