@vercel/board 0.16.0 → 0.18.0

package/dist/events-CewD4kw7.mjs

@@ -0,0 +1,75 @@
+import { d as LabelKey, p as Labels } from "./schemas-Be08nyfW.mjs";
+import { n as ExternalEvent, r as ExternalLocation } from "./external-BV_cUncs.mjs";
+import { z } from "zod";
+//#region src/sync/events.ts
+const EventBase = z.object({
+	id: z.string().min(1),
+	platform: z.string().min(1),
+	key: z.string().min(1),
+	...ExternalLocation.shape,
+	raw: z.unknown()
+});
+const eventTypes = {
+	message: "message",
+	edited: "message.edited",
+	deleted: "message.deleted",
+	reaction: "reaction.added",
+	lifecycle: "lifecycle"
+};
+function envelope(platform, key, event, raw, id) {
+	return {
+		...event,
+		...EventBase.parse({
+			id,
+			platform,
+			key,
+			channel: event.channel,
+			thread: event.thread,
+			subthread: "subthread" in event ? event.subthread : null,
+			raw
+		}),
+		type: event.kind === "lifecycle" ? event.type : event.kind === "reaction" && !event.added ? "reaction.removed" : eventTypes[event.kind]
+	};
+}
+function eventSchema(platform, messageType) {
+	const [message, edited, deleted, reaction, lifecycle] = ExternalEvent.options;
+	const common = {
+		...EventBase.shape,
+		platform: z.literal(platform)
+	};
+	return z.discriminatedUnion("kind", [
+		message.extend({
+			...common,
+			type: z.literal(messageType)
+		}),
+		edited.extend({
+			...common,
+			type: z.literal("message.edited")
+		}),
+		deleted.extend({
+			...common,
+			type: z.literal("message.deleted")
+		}),
+		reaction.extend({
+			...common,
+			type: z.enum(["reaction.added", "reaction.removed"])
+		}),
+		lifecycle.extend(common)
+	]);
+}
+const SyncOverrides = z.object({
+	root: z.custom((value) => typeof value === "function").optional(),
+	text: z.string().optional(),
+	labels: Labels.optional(),
+	unset: z.array(LabelKey).optional(),
+	noSync: z.boolean().optional()
+}).strict();
+function immutable(value) {
+	if (value && typeof value === "object") {
+		for (const item of Object.values(value)) immutable(item);
+		Object.freeze(value);
+	}
+	return value;
+}
+//#endregion
+export { immutable as a, eventSchema as i, SyncOverrides as n, envelope as r, EventBase as t };

package/dist/{exports-Dvc1o52I.mjs → exports-CgjfMrQ-.mjs}

@@ -1,12 +1,13 @@
 import { t as ATTACHMENT_BYTES_MAX } from "./files-SniSmeEr.mjs";
 import "./schemas-Be08nyfW.mjs";
-import { A as SyncBody, B as UploadStartBody, C as Ref, D as SignInQuery, E as SchedulesQuery, F as SyncReceiptBody, I as SyncRootsQuery, L as SyncUnlinkBody, M as SyncCopiesQuery, N as SyncFindQuery, O as SourceReadQuery, P as SyncImportBody, R as ThreadsQuery, S as ReactBody, T as ScheduleBody, _ as InboxQuery, b as MessagesQuery, d as EditBody, f as EventsQuery, g as InboxPushBody, h as InboxNextQuery, j as SyncCodeBody, k as SyncAccountBody, m as InboxAckBody, o as derivedId, p as IdentityUnlinkBody, u as AckBody, v as LabelBody, w as RegisterBody, x as PostBody, y as MatchesQuery, z as TypingBody } from "./watch-spec-W0c7ypHJ.mjs";
-import { n as createBoardClient, t as BoardError } from "./client-DGDPaN7U.mjs";
-import { a as queryObject, c as VERSION, i as openapi, l as SYNC, n as METHODS, o as readCapped, r as createRouter, s as readJson } from "./watchers-hash-CLjsa6od.mjs";
+import { A as ScheduleBody, B as SyncReceiptBody, C as LinkedQuery, D as ReactBody, E as PostBody, F as SyncBody, G as UploadStartBody, H as SyncUnlinkBody, I as SyncCodeBody, L as SyncCopiesQuery, M as SignInQuery, N as SourceReadQuery, O as Ref, P as SyncAccountBody, R as SyncFindQuery, S as LabelBody, T as MessagesQuery, U as ThreadsQuery, V as SyncRootsQuery, W as TypingBody, _ as IdentityUnlinkBody, b as InboxPushBody, c as openapi, d as readJson, f as VERSION, g as EventsQuery, h as EditBody, j as SchedulesQuery, k as RegisterBody, l as queryObject, m as AckBody, o as METHODS, p as SYNC, s as createRouter, u as readCapped, v as InboxAckBody, w as MatchesQuery, x as InboxQuery, y as InboxNextQuery, z as SyncImportBody } from "./watchers-hash-RLtnSF-t.mjs";
+import { n as createBoardClient, t as BoardError } from "./client-BA-J7usH.mjs";
+import { n as derivedId } from "./ids-C6AYo1bu.mjs";
 import { a as forbidden, c as toErrorResponse, l as unauthorized, n as RejectedError, o as json, r as badRequest, s as notFound, t as HttpError } from "./errors-DX3hpwWt.mjs";
-import { i as resolveActor, r as claimsOf, t as KNOWN_AGENTS } from "./actors-DjMeZpnU.mjs";
-import { d as issuersOf, g as verifiesTokens, l as hostPrincipal, o as createAuthority, s as fromTokens } from "./auth-COzc09sn.mjs";
-import { i as DroppedError, n as syncTarget, o as runMiddleware, r as withEmailMentions, t as mentionsEmails } from "./targets-yM5JBUgr.mjs";
+import { d as issuersOf, g as verifiesTokens, l as hostPrincipal, o as createAuthority, s as fromTokens } from "./auth-Drg9FiC2.mjs";
+import { i as resolveActor, r as claimsOf, t as KNOWN_AGENTS } from "./actors-BOamkEuz.mjs";
+import { r as runMiddleware, t as DroppedError } from "./middleware-CqaCwucP.mjs";
+import { n as syncTarget, r as withEmailMentions, t as mentionsEmails } from "./targets-C-wdR5wP.mjs";
 //#region src/server/policy.ts
 /**
 * The policy a board's options say: verifying requests, and `access` over them and over the
@@ -214,6 +215,7 @@ async function inputOf(name, request, url, params) {
 		case "watchers": return {};
 		case "message":
 		case "posted":
+		case "synced":
 		case "delete":
 		case "cancelSchedule":
 		case "attachment":
@@ -296,6 +298,7 @@ async function inputOf(name, request, url, params) {
 			key,
 			...SourceReadQuery.parse(queryObject(url))
 		};
+		case "linked": return LinkedQuery.parse(queryObject(url));
 	}
 }
 /** A platform user, as the middleware is told who's writing. */
@@ -643,9 +646,8 @@ async function createServe(context) {
 		}
 	}
 	/**
-	* A post, with the emails it mentions resolved and the targets its channel syncs with landing
-	* beside it, once the caller may post there (and sync, for targets it names), through the
-	* middleware.
+	* A post, with the emails it mentions resolved once the caller may post there (and sync, for
+	* targets it names), through the middleware.
 	*/
 	async function post(caller, input, signal) {
 		const send = (poster, body) => screenPost(poster, body, signal, (patched) => backend.post(poster, patched, signal));
@@ -653,26 +655,15 @@ async function createServe(context) {
 			...input,
 			sync: await Promise.all(input.sync.map(resolveTarget))
 		} : input);
-		const allowed = (input.sync?.length ?? 0) > 0 || mentionsEmails(input.text) || input.channel !== void 0 && !input.noSync ? await mayPost(caller, input, signal) : null;
+		const allowed = (input.sync?.length ?? 0) > 0 || mentionsEmails(input.text) ? await mayPost(caller, input, signal) : null;
 		if (!allowed) return send(caller, input);
 		const { access, channel } = allowed;
 		const body = input.re === void 0 && (input.sync?.length ?? 0) > 0 && (access === null || access.can("sync", channel)) ? {
 			...input,
 			sync: await Promise.all(input.sync.map(resolveTarget))
 		} : input;
-		let poster = caller;
-		if (body.channel !== void 0 && !body.noSync) {
-			const config = await engine.configTargets(body.channel);
-			if (config.length > 0) poster = {
-				...caller,
-				origin: {
-					...caller.origin,
-					config
-				}
-			};
-		}
 		const text = await withEmails(body.text);
-		const answer = await send(poster, {
+		const answer = await send(caller, {
 			...body,
 			text
 		});
@@ -757,8 +748,7 @@ async function createServe(context) {
 	}
 	/** A sync callback's post, as an import by its platform user: once per client ID, which the backend sees to. */
 	async function importPost(caller, input, signal) {
-		const sync = engine;
-		const me = sync.caller;
+		const me = engine.caller;
 		const { author, key } = caller.platform;
 		const { via } = caller.origin;
 		const read = async (id) => {
@@ -771,14 +761,7 @@ async function createServe(context) {
 			if (found !== null) return { message: await read(found) };
 		}
 		const targets = await Promise.all((input.sync ?? []).map(resolveTarget));
-		const config = input.channel !== void 0 && !input.noSync ? await sync.configTargets(input.channel) : [];
-		const message = await landed(caller, await syncImport(config.length > 0 ? {
-			...me,
-			origin: {
-				...me.origin,
-				config
-			}
-		} : me, {
+		const message = await landed(caller, await syncImport(me, {
 			op: "post",
 			author,
 			from: null,
@@ -1237,6 +1220,26 @@ function createBoard(options, runtime) {
 		pull: async () => ownEntries.length > 0 ? (await server()).pull() : 0,
 		sync: ownEntries,
 		readSource: async (key, target, limit) => (await server()).readSource(key, target, limit),
+		locate: (url) => {
+			const read = /* @__PURE__ */ new Map();
+			for (const entry of Object.values(entries)) {
+				const found = entry.locate(url);
+				if (found) read.set(JSON.stringify([
+					entry.platform,
+					found.thread,
+					found.message
+				]), {
+					platform: entry.platform,
+					...found
+				});
+			}
+			return [...read.values()];
+		},
+		linkOf: async (key, thread, message) => {
+			const entry = Object.hasOwn(entries, key) ? entries[key] : void 0;
+			if (!entry || !thread.startsWith(`${key}:`)) return null;
+			return entry.url(thread.slice(key.length + 1), message).catch(() => null);
+		},
 		typing: async (messages, status) => (await server()).typing(messages, status),
 		accessNow: (principal) => policy.accessNow(principal),
 		project: () => policy.project(),

package/dist/exports-ZsgjzEnM.d.mts

@@ -0,0 +1,4 @@
+import "./auth-CU56Q2Xh.mjs";
+import "./schemas-CWxs3ECJ.mjs";
+import "./provider-B0b9Qxw4.mjs";
+import "./backend-B-SJ7p6p.mjs";

package/dist/external-BV_cUncs.mjs

@@ -0,0 +1,151 @@
+import { h as MessageId, m as MESSAGE_TEXT_MAX } from "./schemas-Be08nyfW.mjs";
+import { z } from "zod";
+//#region src/contract/external.ts
+/**
+* An external thread or channel, prefixed with its sync key:
+* `slack:C0123ABC` (a channel), `slack:C0123ABC:1727.1234` (a thread),
+* `github:basehub-ai/www:12` (a PR thread).
+*/
+const ExternalTarget = z.string().min(3).max(300);
+/** Where a message came from on a platform. `thread` is grouped (GitHub review threads fold into their PR). */
+const Origin = z.object({
+	channel: ExternalTarget.optional(),
+	thread: ExternalTarget,
+	/** The exact platform thread, when it differs from `thread`. */
+	subthread: ExternalTarget.nullable(),
+	message: z.string().min(1).max(300),
+	context: z.string().max(300).nullable()
+});
+/** What a linked message said, as the board saw it when the link arrived. */
+const LinkSnapshot = z.object({
+	author: z.string().min(1).max(256),
+	text: z.string().max(MESSAGE_TEXT_MAX),
+	/** When it was written, if the platform said. */
+	createdAt: z.string().max(64).nullable(),
+	/** Its files, linked rather than copied. */
+	files: z.array(z.object({
+		name: z.string().min(1).max(1e3),
+		url: z.string().max(4e3).nullable()
+	})).max(20)
+});
+/**
+* A platform message linked from a message (a Slack permalink): the board message
+* it was synced to, if any, and a snapshot of it, or why the board couldn't read it.
+*/
+const Link = z.object({
+	url: z.string().min(1).max(4e3),
+	message: MessageId.nullable(),
+	snapshot: LinkSnapshot.nullable(),
+	/** Why there's no snapshot: `not_in_channel`, `channel_not_found`. */
+	unavailable: z.string().max(300).nullable()
+});
+const ExternalAuthor = z.object({
+	/** The platform principal, e.g. `slack:user:U0456`. */
+	id: z.string().min(1),
+	handle: z.string().min(1),
+	name: z.string().min(1),
+	avatar: z.string().nullable(),
+	isBot: z.boolean()
+});
+/**
+* A file on a platform message, as Chat SDK describes it: enough for the
+* platform's adapter to fetch it later (`rehydrateAttachment`), never the bytes.
+*/
+const ExternalFile = z.object({
+	type: z.enum([
+		"image",
+		"file",
+		"video",
+		"audio"
+	]),
+	name: z.string().max(1e3).optional(),
+	mimeType: z.string().max(255).optional(),
+	size: z.number().int().nonnegative().optional(),
+	url: z.string().max(4e3).optional(),
+	fetchMetadata: z.record(z.string(), z.string().max(4e3)).optional()
+});
+/**
+* A platform message a platform message links to, at intake: where it lives
+* (`thread`, with the sync key prefix, and `message`), and what it said when the
+* platform sent that along (Slack's unfurl).
+*/
+const ExternalLink = z.object({
+	url: z.string().min(1).max(4e3),
+	thread: ExternalTarget,
+	message: z.string().min(1).max(300),
+	snapshot: LinkSnapshot.nullable()
+});
+const ExternalLocation = z.object({
+	channel: ExternalTarget,
+	thread: ExternalTarget,
+	subthread: ExternalTarget.nullable()
+});
+/** A platform event, normalized at intake. Thread IDs are external IDs with the sync key prefix. */
+const ExternalEvent = z.discriminatedUnion("kind", [
+	z.object({
+		kind: z.literal("message"),
+		...ExternalLocation.shape,
+		message: z.string(),
+		isRoot: z.boolean(),
+		text: z.string(),
+		context: z.string().nullable(),
+		author: ExternalAuthor,
+		/** Files on the message, fetched when it lands on the board. Older events have none. */
+		files: z.array(ExternalFile).max(20).optional(),
+		/** Platform messages it links to. Older events have none. */
+		links: z.array(ExternalLink).max(10).optional()
+	}),
+	z.object({
+		kind: z.literal("edited"),
+		...ExternalLocation.shape,
+		message: z.string(),
+		text: z.string(),
+		author: ExternalAuthor,
+		links: z.array(ExternalLink).max(10).optional(),
+		/** Only the links changed (the platform sent what they say), so `text` isn't news. */
+		linksOnly: z.boolean().optional()
+	}),
+	z.object({
+		kind: z.literal("deleted"),
+		...ExternalLocation.shape,
+		message: z.string()
+	}),
+	z.object({
+		kind: z.literal("reaction"),
+		...ExternalLocation.shape,
+		message: z.string(),
+		emoji: z.string(),
+		added: z.boolean(),
+		author: ExternalAuthor
+	}),
+	z.object({
+		/** A platform lifecycle event: a PR opening, closing, being reviewed. */
+		kind: z.literal("lifecycle"),
+		...ExternalLocation.omit({ subthread: true }).shape,
+		type: z.string(),
+		title: z.string(),
+		url: z.string().nullable(),
+		labels: z.record(z.string(), z.string()),
+		unset: z.array(z.string()),
+		/** Key prefixes the platform owns on the root, e.g. `tag.`: keys under them that aren't in `labels` are unset. */
+		owns: z.array(z.string()).optional(),
+		/** A reply to add to the thread, e.g. "merged by julian". */
+		reply: z.string().nullable(),
+		/** Create the root if the board hasn't seen this thread. */
+		createRoot: z.boolean(),
+		/** The thread's title changed on the platform: a root that came from it says the new one. */
+		retitled: z.boolean().optional(),
+		author: ExternalAuthor
+	})
+]);
+/** `slack:C0123ABC:1727.1234` is a thread; `slack:C0123ABC` and `github:owner/repo` are channels. */
+const isThreadTarget = (target) => target.slice(target.indexOf(":") + 1).includes(":");
+/** `slack:C0123ABC:1727.1` → `slack:C0123ABC`; `github:o/r:12` → `github:o/r`. */
+const channelOf = (externalThread) => {
+	const at = externalThread.indexOf(":");
+	const colon = externalThread.slice(at + 1).indexOf(":");
+	return colon === -1 ? externalThread : externalThread.slice(0, at + 1 + colon);
+};
+const externalMessageKey = (thread, message) => `${thread}|${message}`;
+//#endregion
+export { Link as a, externalMessageKey as c, ExternalTarget as i, isThreadTarget as l, ExternalEvent as n, Origin as o, ExternalLocation as r, channelOf as s, ExternalAuthor as t };