pi-roundtable-webchat 0.8.0 → 0.9.0

package/src/tickets.ts

@@ -14,6 +14,7 @@ export interface TicketBookOptions {
 }
 
 interface Held {
+	principalId: string;
 	identity: WebIdentity;
 	expiresAt: number;
 }
@@ -40,10 +41,13 @@ export class TicketBook {
 		this.#now = options.now ?? Date.now;
 	}
 
-	issue(identity: WebIdentity): { ticket: string; expiresAt: Date } {
+	issue(
+		identity: WebIdentity,
+		principalId: string,
+	): { ticket: string; expiresAt: Date } {
 		const now = this.#now();
 		this.#sweep(now);
-		const mine = this.#byPerson.get(identity.id) ?? new Set<string>();
+		const mine = this.#byPerson.get(principalId) ?? new Set<string>();
 		for (const oldest of mine) {
 			if (mine.size < this.#perPrincipal) break;
 			this.#drop(oldest);
@@ -57,27 +61,31 @@ export class TicketBook {
 			crypto.getRandomValues(new Uint8Array(32)),
 		).toString("base64url");
 		const expiresAt = Math.min(now + this.#ttlMs, identity.expiresAt.getTime());
-		this.#held.set(ticket, { identity, expiresAt });
+		this.#held.set(ticket, { identity, principalId, expiresAt });
 		mine.add(ticket);
-		this.#byPerson.set(identity.id, mine);
+		this.#byPerson.set(principalId, mine);
 		return { ticket, expiresAt: new Date(expiresAt) };
 	}
 
 	/** The person the ticket was issued to, once; undefined for a spent, old, or unknown ticket. */
-	redeem(ticket: string): WebIdentity | undefined {
+	redeem(
+		ticket: string,
+	): { identity: WebIdentity; principalId: string } | undefined {
 		const held = this.#held.get(ticket);
 		if (!held) return undefined;
 		this.#drop(ticket);
-		return held.expiresAt >= this.#now() ? held.identity : undefined;
+		return held.expiresAt >= this.#now()
+			? { identity: held.identity, principalId: held.principalId }
+			: undefined;
 	}
 
 	#drop(ticket: string): void {
 		const held = this.#held.get(ticket);
 		if (!held) return;
 		this.#held.delete(ticket);
-		const mine = this.#byPerson.get(held.identity.id);
+		const mine = this.#byPerson.get(held.principalId);
 		mine?.delete(ticket);
-		if (mine?.size === 0) this.#byPerson.delete(held.identity.id);
+		if (mine?.size === 0) this.#byPerson.delete(held.principalId);
 	}
 
 	#sweep(now: number): void {

package/src/access.ts

@@ -1,99 +0,0 @@
-import type { Tier } from "pi-roundtable";
-import type { WebIdentity } from "./oidc.ts";
-
-/** Who holds a tier: speaker ids, role or group names from the token, or everyone the provider signs in. */
-export interface WebTierMembers {
-	users?: readonly string[];
-	roles?: readonly string[];
-	everyone?: boolean;
-}
-
-/**
- * Who may chat, and at which tier. Owners are named only by speaker id, so no claim a provider
- * issues can make someone the owner; admins and members may be named by role as well. A person
- * the map gives no tier is not admitted: no connection, no conversation, no turn.
- */
-export interface WebAccessMap {
-	/** Speaker ids, such as `oidcSpeakerId(issuer, subject)`; never roles. */
-	owners?: readonly string[];
-	admins?: WebTierMembers;
-	members?: WebTierMembers;
-}
-
-/** The tier a verified person chats at, or undefined when they are not admitted. */
-export interface WebAccess {
-	tierOf(identity: WebIdentity): Tier | undefined;
-}
-
-const isStrings = (value: unknown): value is readonly string[] =>
-	Array.isArray(value) && value.every((item) => typeof item === "string");
-
-/**
- * Throws unless `tier` is a `WebTierMembers` whose `users` and `roles` are lists of strings and
- * whose `everyone` is a boolean: a JavaScript configuration is not type-checked, and a string
- * where a list belongs would match its substrings.
- */
-function checkTier(name: string, tier: unknown): void {
-	if (tier === undefined) return;
-	if (typeof tier !== "object" || tier === null || Array.isArray(tier))
-		throw new Error(
-			`webAccess: ${name} is { users?, roles?, everyone? }; got ${JSON.stringify(tier)}`,
-		);
-	const { users, roles, everyone } = tier as Record<string, unknown>;
-	for (const [field, value] of [
-		["users", users],
-		["roles", roles],
-	] as const)
-		if (value !== undefined && !isStrings(value))
-			throw new Error(
-				`webAccess: ${name}.${field} must be a list of strings; got ${JSON.stringify(value)}`,
-			);
-	if (everyone !== undefined && typeof everyone !== "boolean")
-		throw new Error(
-			`webAccess: ${name}.everyone must be true or false; got ${JSON.stringify(everyone)}`,
-		);
-}
-
-function admitsSomeone(tier: WebTierMembers | undefined): boolean {
-	return (
-		tier !== undefined &&
-		(tier.everyone === true ||
-			(tier.users?.length ?? 0) > 0 ||
-			(tier.roles?.length ?? 0) > 0)
-	);
-}
-
-/**
- * The policy of an access map: the highest tier a person qualifies for wins. A map that admits
- * no one is a configuration mistake and throws.
- */
-export function webAccess(map: WebAccessMap): WebAccess {
-	if (map.owners !== undefined && !isStrings(map.owners))
-		throw new Error(
-			"webAccess: owners is a list of speaker ids; a provider's roles cannot name an owner",
-		);
-	checkTier("admins", map.admins);
-	checkTier("members", map.members);
-	const owners = new Set(map.owners ?? []);
-	if (
-		owners.size === 0 &&
-		!admitsSomeone(map.admins) &&
-		!admitsSomeone(map.members)
-	)
-		throw new Error(
-			"webAccess: the map admits no one; name owners, or admins or members by user, role, or everyone",
-		);
-	const holds = (tier: WebTierMembers | undefined, identity: WebIdentity) =>
-		tier !== undefined &&
-		(tier.everyone === true ||
-			tier.users?.includes(identity.id) === true ||
-			identity.roles.some((role) => tier.roles?.includes(role)));
-	return {
-		tierOf(identity) {
-			if (owners.has(identity.id)) return "owner";
-			if (holds(map.admins, identity)) return "admin";
-			if (holds(map.members, identity)) return "member";
-			return undefined;
-		},
-	};
-}