@protobase/client 0.62.5 → 0.63.0

package/dist/call-guests.js

@@ -0,0 +1,24 @@
+import { guestCallsPath } from "@protobase/schema/internal";
+//#region src/call-guests.ts
+/**
+* Whether the calls of the organization the signed-in user works in take guests (`/api/calls/guests/organization`):
+* `allowed` for any member, `setAllowed` for its owner or an admin. Turning them off revokes every guest link of its
+* calls and takes their guests out at once.
+*/
+const callGuestsClient = (send) => ({
+	allowed: async () => (await (await send({
+		method: "GET",
+		path: guestCallsPath("", "organization"),
+		system: true
+	})).json()).allowed,
+	setAllowed: async (allowed) => {
+		await send({
+			method: "PUT",
+			path: guestCallsPath("", "organization"),
+			system: true,
+			body: { allowed }
+		});
+	}
+});
+//#endregion
+export { callGuestsClient };

package/dist/calls/guest-lobby.d.ts

@@ -0,0 +1,34 @@
+import { CallGuestState, CallTrackSource } from "@protobase/schema/internal";
+//#region src/calls/guest-lobby.d.ts
+/** A guest's wait in the lobby, as the server tells it: once let in, the call and what the guest may send. */
+export type GuestWait = {
+  state: CallGuestState;
+  call?: string;
+  publish?: CallTrackSource[];
+};
+/** Why the lobby did not answer: no live link, too many tries for now, or a name it does not take. */
+export declare class LobbyRefused extends Error {
+  readonly status: number;
+  constructor(status: number, message: string);
+}
+export type GuestLobbyOptions = {
+  /** The API's system path on the page's origin, `/api` by default. */
+  systemPath?: string;
+  fetch?: typeof fetch;
+};
+/**
+ * The lobby a guest of a call waits in, with no account: `enter` with the link's token and the guest's name gives the
+ * guest's own token, which `wait` and `leave` send, and which `joinCall` takes as `guest` at `socketUrl` once a member
+ * let them in. No cookie is sent or kept.
+ */
+export declare const guestLobby: ({ systemPath, fetch: fetchOf }?: GuestLobbyOptions) => {
+  /** The guest's call socket, for `joinCall`'s `url`. */
+  socketUrl: string;
+  enter: (link: string, name: string) => Promise<{
+    guest: string;
+    token: string;
+  }>;
+  wait: (token: string) => Promise<GuestWait>;
+  leave: (token: string) => Promise<void>;
+};
+//#endregion

package/dist/calls/guest-lobby.js

@@ -0,0 +1,53 @@
+import { guestCallsPath } from "@protobase/schema/internal";
+//#region src/calls/guest-lobby.ts
+/** Why the lobby did not answer: no live link, too many tries for now, or a name it does not take. */
+var LobbyRefused = class extends Error {
+	status;
+	constructor(status, message) {
+		super(message);
+		this.status = status;
+		this.name = "LobbyRefused";
+	}
+};
+/**
+* The lobby a guest of a call waits in, with no account: `enter` with the link's token and the guest's name gives the
+* guest's own token, which `wait` and `leave` send, and which `joinCall` takes as `guest` at `socketUrl` once a member
+* let them in. No cookie is sent or kept.
+*/
+const guestLobby = ({ systemPath = "/api", fetch: fetchOf = globalThis.fetch } = {}) => {
+	const lobby = guestCallsPath(systemPath, "lobby");
+	const ask = async (init) => {
+		const response = await fetchOf(lobby, {
+			...init,
+			credentials: "omit",
+			cache: "no-store"
+		});
+		if (!response.ok) throw new LobbyRefused(response.status, (await response.json().catch(() => void 0))?.detail ?? response.statusText);
+		return response;
+	};
+	const bearer = (token) => ({ authorization: `Bearer ${token}` });
+	return {
+		/** The guest's call socket, for `joinCall`'s `url`. */
+		socketUrl: guestCallsPath(systemPath, "socket"),
+		enter: async (link, name) => await (await ask({
+			method: "POST",
+			headers: { "content-type": "application/json" },
+			body: JSON.stringify({
+				link,
+				name
+			})
+		})).json(),
+		wait: async (token) => await (await ask({
+			method: "GET",
+			headers: bearer(token)
+		})).json(),
+		leave: async (token) => {
+			await ask({
+				method: "DELETE",
+				headers: bearer(token)
+			});
+		}
+	};
+};
+//#endregion
+export { LobbyRefused, guestLobby };

package/dist/calls/guest-requests.d.ts

@@ -0,0 +1,25 @@
+import { CallGuestLink, CallGuestRefusal, CallTrackSource } from "@protobase/schema/internal";
+//#region src/calls/guest-requests.d.ts
+/** A guest request the server did not do, with why: see `CallGuestRefusal`. */
+export declare class GuestRefused extends Error {
+  readonly reason: CallGuestRefusal;
+  constructor(reason: CallGuestRefusal);
+}
+/** What a member who invites does with the call's guests. Each rejects with `GuestRefused` when the server did not. */
+export type CallGuests = {
+  /** A new link to the call that lets a guest send these sources, until `expiresAt` or the call's end; its token once. */
+  link: (options: {
+    publish: CallTrackSource[];
+    expiresAt?: Date;
+  }) => Promise<{
+    link: CallGuestLink;
+    token: string;
+  }>;
+  /** Revokes a link: its guests are out of the call, and nobody else waits on it. */
+  revoke: (link: string) => Promise<void>;
+  admit: (guest: string) => Promise<void>;
+  deny: (guest: string) => Promise<void>;
+  /** Takes a guest out of the call, for good. */
+  remove: (guest: string) => Promise<void>;
+};
+//#endregion

package/dist/calls/guest-requests.js

@@ -0,0 +1,68 @@
+//#region src/calls/guest-requests.ts
+/** A guest request the server did not do, with why: see `CallGuestRefusal`. */
+var GuestRefused = class extends Error {
+	reason;
+	constructor(reason) {
+		super(`The guest request was refused: ${reason}`);
+		this.reason = reason;
+		this.name = "GuestRefused";
+	}
+};
+/**
+* The member's guest requests over the call's socket: the server answers each once, in order, so the answers are paired
+* with the requests in the order they were sent. A request whose socket closed before its answer rejects.
+*/
+const guestRequests = (send) => {
+	const pending = [];
+	const ask = (message) => new Promise((resolve, reject) => {
+		pending.push({
+			resolve,
+			reject
+		});
+		send(message);
+	});
+	return {
+		guests: {
+			link: ({ publish, expiresAt }) => ask({
+				type: "guest-link",
+				publish,
+				...expiresAt && { expires_at: expiresAt.toISOString() }
+			}),
+			revoke: (link) => ask({
+				type: "guest-link-revoke",
+				link
+			}),
+			admit: (guest) => ask({
+				type: "guest-decide",
+				guest,
+				admit: true
+			}),
+			deny: (guest) => ask({
+				type: "guest-decide",
+				guest,
+				admit: false
+			}),
+			remove: (guest) => ask({
+				type: "guest-remove",
+				guest
+			})
+		},
+		/** Whether the message answered a request, which it then settles. */
+		receive: (message) => {
+			if (message.type !== "guest-link" && message.type !== "guest-done" && message.type !== "guest-refused") return false;
+			const request = pending.shift();
+			if (message.type === "guest-refused") request?.reject(new GuestRefused(message.reason));
+			else request?.resolve(message.type === "guest-link" ? {
+				link: message.link,
+				token: message.token
+			} : void 0);
+			return true;
+		},
+		/** The socket closed: the requests on it are not answered. */
+		lost: () => {
+			for (const request of pending.splice(0)) request.reject(/* @__PURE__ */ new Error("The link to the call was lost before the server answered"));
+		}
+	};
+};
+//#endregion
+export { GuestRefused, guestRequests };

package/dist/calls/index.d.ts

@@ -1,6 +1,8 @@
 import { CallConnection } from "./connection-stats.js";
+import { CallGuests, GuestRefused } from "./guest-requests.js";
 import { CallTrack, PublishOptions } from "./media-link.js";
 import { Call, CallState, JoinCallOptions, joinCall } from "./join-call.js";
 import { PublishRefused } from "./publish-refused.js";
-import { CallLeftReason, CallMode, CallRosterMember, CallTrackSource } from "@protobase/schema/internal";
-export { type Call, type CallConnection, type CallLeftReason, type CallMode, type CallRosterMember, type CallState, type CallTrack, type CallTrackSource, type JoinCallOptions, type PublishOptions, PublishRefused, joinCall };
+import { GuestLobbyOptions, GuestWait, LobbyRefused, guestLobby } from "./guest-lobby.js";
+import { CallGuestLink, CallGuestRefusal, CallGuestState, CallLeftReason, CallLobbyGuest, CallMode, CallRosterMember, CallTrackSource } from "@protobase/schema/internal";
+export { type Call, type CallConnection, type CallGuestLink, type CallGuestRefusal, type CallGuestState, type CallGuests, type CallLeftReason, type CallLobbyGuest, type CallMode, type CallRosterMember, type CallState, type CallTrack, type CallTrackSource, type GuestLobbyOptions, GuestRefused, type GuestWait, type JoinCallOptions, LobbyRefused, type PublishOptions, PublishRefused, guestLobby, joinCall };

package/dist/calls/index.js

@@ -1,3 +1,5 @@
+import { GuestRefused } from "./guest-requests.js";
 import { PublishRefused } from "./publish-refused.js";
 import { joinCall } from "./join-call.js";
-export { PublishRefused, joinCall };
+import { LobbyRefused, guestLobby } from "./guest-lobby.js";
+export { GuestRefused, LobbyRefused, PublishRefused, guestLobby, joinCall };

package/dist/calls/join-call.d.ts

@@ -1,6 +1,7 @@
 import { CallConnection } from "./connection-stats.js";
+import { CallGuests } from "./guest-requests.js";
 import { CallTrack, PublishOptions } from "./media-link.js";
-import { CallLeftReason, CallRosterMember, CallTrackSource } from "@protobase/schema/internal";
+import { CallGuestLink, CallLeftReason, CallLobbyGuest, CallRosterMember, CallTrackSource } from "@protobase/schema/internal";
 //#region src/calls/join-call.d.ts
 /** Where a call stands: `resuming` while the link to Protobase is restored, with media still flowing. */
 export type CallState = {
@@ -20,6 +21,13 @@ export type JoinCallOptions = {
    * page's origin, or an absolute `http(s)` or `ws(s)` URL. The browser sends its session cookie with it.
    */
   url: string;
+  /** A guest's token from `guestLobby`, with the lobby's `socketUrl` as `url`: the guest joins as themselves, whom no cookie names. */
+  guest?: string;
+  /** With a member who may invite: who waits in the call's lobby, and its guest links, whenever that changes. */
+  onLobby?: (lobby: {
+    guests: CallLobbyGuest[];
+    links: CallGuestLink[];
+  }) => void;
   /** Every track of other members the member hears, whenever one comes, goes or its media arrives. */
   onTracks?: (tracks: CallTrack[]) => void;
   /** Everyone in the call, the member too, in the order they came, whenever that changes. */
@@ -62,6 +70,8 @@ export type Call = {
   tracks: () => CallTrack[];
   /** How each of the member's connections fares now: to each other member, or to the media server. */
   connections: () => Promise<CallConnection[]>;
+  /** With a member who may invite: guest links, and letting the lobby's guests in. */
+  guests: CallGuests;
 };
 /**
  * Joins a call through the app's function socket and resolves once the member is in it. Media flows over plain

package/dist/calls/join-call.js

@@ -1,3 +1,4 @@
+import { guestRequests } from "./guest-requests.js";
 import { peerLink } from "./peer-link.js";
 import { sfuLink } from "./sfu-link.js";
 //#region src/calls/join-call.ts
@@ -45,6 +46,8 @@ const joinCall = (options) => {
 	const send = (message) => {
 		if (socket.readyState === WebSocketOf.OPEN) socket.send(JSON.stringify(message));
 	};
+	const requests = guestRequests(send);
+	const guest = options.guest !== void 0 ? { guest: options.guest } : {};
 	const setState = (state) => options.onState?.(state);
 	const end = (reason, error) => {
 		if (ended) return;
@@ -103,7 +106,15 @@ const joinCall = (options) => {
 				if (message.reason === "rejoin") rejoin = true;
 				else end(message.reason);
 				return;
-			default: await link?.receive(message);
+			case "lobby":
+				options.onLobby?.({
+					guests: message.guests,
+					links: message.links
+				});
+				return;
+			default:
+				if (requests.receive(message)) return;
+				await link?.receive(message);
 		}
 	};
 	const connect = (mode) => {
@@ -117,8 +128,12 @@ const joinCall = (options) => {
 				send(resume ? {
 					type: "resume",
 					call: callId,
-					...resume
-				} : { type: "join" });
+					...resume,
+					...guest
+				} : {
+					type: "join",
+					...guest
+				});
 			});
 		};
 		socket.onmessage = (event) => {
@@ -126,6 +141,7 @@ const joinCall = (options) => {
 			chain = chain.then(() => handle(message)).catch((error) => end("ended", error));
 		};
 		socket.onclose = (event) => {
+			requests.lost();
 			chain = chain.then(() => closed(mode, event.code));
 		};
 	};
@@ -182,7 +198,8 @@ const joinCall = (options) => {
 			end("ended");
 		},
 		tracks: () => remote,
-		connections: async () => link ? link.connections() : []
+		connections: async () => link ? link.connections() : [],
+		guests: requests.guests
 	};
 	setState({ state: "connecting" });
 	connect("join");

package/dist/client.d.ts

@@ -125,6 +125,10 @@ export declare const createClient: (options?: ClientOptions) => {
     list: () => Promise<import("@protobase/schema/internal").CallRing[]>;
     decline: (call: string) => Promise<void>;
   };
+  callGuests: {
+    allowed: () => Promise<boolean>;
+    setAllowed: (allowed: boolean) => Promise<void>;
+  };
 };
 export type Client = ReturnType<typeof createClient>;
 //#endregion

package/dist/client.js

@@ -10,6 +10,7 @@ import { statusClient } from "./status.js";
 import { notificationHistoryClient } from "./notification-history.js";
 import { recordCallsClient } from "./record-calls.js";
 import { ringsClient } from "./rings.js";
+import { callGuestsClient } from "./call-guests.js";
 import { encodeKey } from "@protobase/schema/internal";
 //#region src/client.ts
 const nameOf = (resource) => typeof resource === "string" ? resource : resource.toModel().name;
@@ -475,7 +476,8 @@ const createClient = (options = {}) => {
 		status: statusClient(send),
 		calls,
 		watchCalls,
-		rings: ringsClient(send)
+		rings: ringsClient(send),
+		callGuests: callGuestsClient(send)
 	};
 };
 //#endregion

package/dist/routed-client.js

@@ -45,6 +45,7 @@ const routedClient = (own, sourceOf) => {
 		notifications: own.notifications,
 		status: own.status,
 		rings: own.rings,
+		callGuests: own.callGuests,
 		calls: (resource, key) => to(resource).calls(resource, key),
 		watchCalls: (resource, key, handlers) => to(resource).watchCalls(resource, key, handlers)
 	};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@protobase/client",
-  "version": "0.62.5",
+  "version": "0.63.0",
   "description": "Typed fetch client for the Protobase REST API.",
   "license": "Apache-2.0",
   "repository": {
@@ -31,8 +31,8 @@
   },
   "dependencies": {
     "@better-auth/passkey": "^1.7.12",
-    "@protobase/layout": "0.62.5",
-    "@protobase/schema": "0.62.5",
+    "@protobase/layout": "0.63.0",
+    "@protobase/schema": "0.63.0",
     "@simplewebauthn/browser": "^13.3.0",
     "better-auth": "^1.7.12"
   }