@vercel/board 0.0.0-stage → 0.15.0

package/dist/watchers-hash-D9hbHLKB.mjs

@@ -0,0 +1,225 @@
+import { t as ATTACHMENT_BYTES_MAX } from "./files-SniSmeEr.mjs";
+import "./schemas-Be08nyfW.mjs";
+import { V as routes } from "./watch-spec-W0c7ypHJ.mjs";
+import { r as badRequest, t as HttpError } from "./errors-DX3hpwWt.mjs";
+import { z } from "zod";
+//#region src/server/backend.ts
+/** The subscription sync's outbound runs on, in `BoardBinding.subscriptions`. No watcher's ID starts with `@`. */
+const SYNC = "@sync";
+//#endregion
+//#region src/version.ts
+const VERSION = "0.15.0";
+//#endregion
+//#region src/server/routing.ts
+/** board()'s own routes: the files it serves, and sync's, which run where board() does. */
+const BOARD_ROUTES = [
+	"avatar",
+	"openapi",
+	"webhook",
+	"signIn",
+	"signedIn",
+	"identityUnlink",
+	"sync"
+];
+/** Every protocol method, by the route it's served at. */
+const METHODS = [
+	"discovery",
+	"me",
+	"channels",
+	"actors",
+	"identity",
+	"messages",
+	"threads",
+	"message",
+	"post",
+	"posted",
+	"edit",
+	"delete",
+	"react",
+	"label",
+	"schedule",
+	"schedules",
+	"cancelSchedule",
+	"upload",
+	"attachment",
+	"uploadStart",
+	"uploadFinish",
+	"watchers",
+	"register",
+	"matches",
+	"ack",
+	"events",
+	"syncImport",
+	"syncReceipt",
+	"syncThread",
+	"syncFind",
+	"syncCopies",
+	"syncRoots",
+	"inboxPush",
+	"inboxNext",
+	"inboxAck",
+	"inbox",
+	"syncCode",
+	"syncAccount",
+	"syncUnlink",
+	"typing",
+	"readSource"
+];
+const escape = (literal) => literal.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+function compile(method, path, target, own) {
+	const parts = path.split("/").filter(Boolean);
+	const source = parts.map((part) => part.startsWith(":") ? "/([^/]+)" : `/${escape(part)}`).join("");
+	return {
+		method,
+		pattern: new RegExp(`${source}$`),
+		names: parts.filter((part) => part.startsWith(":")).map((part) => part.slice(1)),
+		target,
+		segments: parts.length,
+		literals: parts.filter((part) => !part.startsWith(":")).length,
+		own
+	};
+}
+/**
+* The routes a board answers, most specific first: each is matched as a suffix of the request's
+* path, so `/api/board/messages/12` is `GET /messages/:id` under `/api/board`. A backend's own
+* route at a protocol path takes its place. Discovery is the mount itself.
+*/
+function createRouter(backendRoutes, basePath) {
+	const patterns = [
+		...BOARD_ROUTES.map((name) => compile(routes[name].method, routes[name].path, {
+			kind: "board",
+			name
+		}, false)),
+		...METHODS.filter((name) => name !== "discovery").map((name) => compile(routes[name].method, routes[name].path, {
+			kind: "protocol",
+			name
+		}, false)),
+		...backendRoutes.map((route) => compile(route.method, route.path, {
+			kind: "backend",
+			route
+		}, true))
+	].sort((a, b) => b.segments - a.segments || b.literals - a.literals || Number(b.own) - Number(a.own));
+	/** A segment that isn't URI-encoded names nothing: no route. */
+	const found = (candidate, base, values) => {
+		const params = {};
+		try {
+			candidate.names.forEach((name, i) => params[name] = decodeURIComponent(values[i]));
+		} catch {
+			return null;
+		}
+		const first = candidate.names[0];
+		return {
+			target: candidate.target,
+			base,
+			param: first === void 0 ? null : params[first],
+			params
+		};
+	};
+	const discovery = (base) => ({
+		target: {
+			kind: "protocol",
+			name: "discovery"
+		},
+		base,
+		param: null,
+		params: {},
+		root: true
+	});
+	return function route(method, pathname) {
+		const path = pathname.length > 1 ? pathname.replace(/\/+$/, "") : pathname;
+		if (basePath !== void 0) {
+			const base = basePath.replace(/\/+$/, "");
+			if (path !== base && !path.startsWith(`${base}/`)) return null;
+			const rest = path.slice(base.length) || "/";
+			if (rest === "/") return method === "GET" ? discovery(base) : null;
+			for (const candidate of patterns) {
+				const hit = candidate.method === method ? rest.match(new RegExp(`^${candidate.pattern.source}`)) : null;
+				if (hit) return found(candidate, base, hit.slice(1));
+			}
+			return null;
+		}
+		for (const candidate of patterns) {
+			if (candidate.method !== method) continue;
+			const hit = path.match(candidate.pattern);
+			if (hit) return found(candidate, path.slice(0, hit.index), hit.slice(1));
+		}
+		return method === "GET" ? discovery(path === "/" ? "" : path) : null;
+	};
+}
+function queryObject(url) {
+	const out = {};
+	for (const key of new Set(url.searchParams.keys())) {
+		const values = url.searchParams.getAll(key);
+		out[key] = values.length > 1 ? values : values[0];
+	}
+	return out;
+}
+async function readJson(request) {
+	const text = await request.text();
+	if (text.trim() === "") return void 0;
+	try {
+		return JSON.parse(text);
+	} catch {
+		throw badRequest("request body is not valid JSON");
+	}
+}
+const tooLarge = () => new HttpError(413, "too_large", `attachments are at most ${ATTACHMENT_BYTES_MAX / 1024 / 1024} MB`);
+/** The body, refused as soon as it's past `max`: with or without a `content-length`, it never reads more. */
+async function readCapped(request, max) {
+	if (Number(request.headers.get("content-length") ?? 0) > max) throw tooLarge();
+	const chunks = [];
+	let size = 0;
+	for await (const chunk of request.body ?? []) {
+		size += chunk.byteLength;
+		if (size > max) throw tooLarge();
+		chunks.push(chunk);
+	}
+	const body = new Uint8Array(size);
+	let at = 0;
+	for (const chunk of chunks) {
+		body.set(chunk, at);
+		at += chunk.byteLength;
+	}
+	return body;
+}
+function openapi() {
+	const paths = {};
+	for (const [name, definition] of Object.entries(routes)) {
+		const path = definition.path.replace(/:(\w+)/g, "{$1}");
+		const operation = { operationId: name };
+		if ("query" in definition) operation["x-query-schema"] = z.toJSONSchema(definition.query, { io: "input" });
+		if ("body" in definition) operation.requestBody = { content: { "application/json": { schema: z.toJSONSchema(definition.body, { io: "input" }) } } };
+		(paths[path] ??= {})[definition.method.toLowerCase()] = operation;
+	}
+	return {
+		openapi: "3.1.0",
+		info: {
+			title: "board",
+			version: VERSION
+		},
+		paths
+	};
+}
+//#endregion
+//#region src/server/watchers-hash.ts
+/** By UTF-16 code unit, as `sort()` orders strings: the same in every locale and runtime. */
+const byCodeUnit = (a, b) => a < b ? -1 : a > b ? 1 : 0;
+/**
+* What `watchersHash` hashes, the same on both ends: a board on `http()` hashes its watchers, and
+* whether its sync subscribes, and the board it uses hashes what it holds.
+*/
+function canonicalWatchers(watch, sync = []) {
+	const canonical = Object.keys(watch).sort(byCodeUnit).map((id) => [
+		id,
+		watch[id].tail,
+		watch[id].when
+	]);
+	if (sync.length > 0) canonical.push(["sync", [...sync].sort((a, b) => byCodeUnit(a.key, b.key)).map((entry) => [
+		entry.key,
+		entry.platform,
+		entry.signIn
+	])]);
+	return JSON.stringify(canonical);
+}
+//#endregion
+export { queryObject as a, VERSION as c, openapi as i, SYNC as l, METHODS as n, readCapped as o, createRouter as r, readJson as s, canonicalWatchers as t };