pi-roundtable 0.30.4 → 0.31.1

package/src/core/discord/poster/rest-poster.ts

@@ -11,12 +11,14 @@ import {
 	invalid,
 } from "./poster-checks.ts";
 import { DiscordPosterError, failure, isCode } from "./poster-errors.ts";
+import { THREAD_ARCHIVED } from "./poster-forum.ts";
 import {
 	type DiscordRest,
 	object,
 	restCore,
 	text,
 } from "./rest-poster-core.ts";
+import { forumOperations } from "./rest-poster-forum.ts";
 import { guildOperations } from "./rest-poster-guild.ts";
 import { readOperations } from "./rest-poster-read.ts";
 
@@ -214,6 +216,7 @@ export function restPoster(
 
 	return {
 		...guild,
+		...forumOperations(core),
 		async post(channelId, post) {
 			checkSnowflake("a channel", channelId);
 			const { webhook: name, body, files } = checkedPost(post);
@@ -362,13 +365,23 @@ export function restPoster(
 		async editCard(channelId, messageId, card) {
 			checkSnowflake("a channel", channelId);
 			checkSnowflake("a message", messageId);
-			await rest
-				.patch(Routes.channelMessage(channelId, messageId), {
-					body: cardBody(card),
-				})
-				.catch((error: unknown) => {
+			const body = cardBody(card);
+			const edit = () =>
+				rest.patch(Routes.channelMessage(channelId, messageId), { body });
+			try {
+				await edit();
+			} catch (error) {
+				// A forum post's first message has the post's own id. Discord refuses its edit while the
+				// post is archived (50083), so the post is opened again and the edit sent once more.
+				if (channelId !== messageId || !isCode(error, THREAD_ARCHIVED))
 					throw failure("editing a card", error);
-				});
+				await rest
+					.patch(Routes.channel(channelId), { body: { archived: false } })
+					.then(edit)
+					.catch((again: unknown) => {
+						throw failure("editing a card", again);
+					});
+			}
 		},
 		async deleteAsBot(channelId, messageId) {
 			checkSnowflake("a channel", channelId);

package/src/core/testing/fake-poster-cards.ts

@@ -0,0 +1,27 @@
+import type { DiscordCard } from "../discord/poster/poster.ts";
+import { DiscordPosterError } from "../discord/poster/poster-errors.ts";
+import { flatPreview } from "../discord/poster/poster-legacy-card.ts";
+import { cardText } from "./fake-poster-guild.ts";
+
+/**
+ * The `content` the fake keeps for a card message: the preview line of a card that has one (as
+ * Discord holds it), else the card as plain text for a test to read.
+ */
+export function cardContent(card: DiscordCard): string {
+	return card.preview === undefined
+		? cardText(card)
+		: flatPreview(card.preview);
+}
+
+/**
+ * Refuses an edit that changes a message's kind: a Components V2 message cannot be edited into a
+ * `preview` (legacy) card, and a legacy message cannot become a Components V2 card.
+ */
+export function assertSameCardKind(held: DiscordCard, edit: DiscordCard): void {
+	if ((held.preview !== undefined) !== (edit.preview !== undefined))
+		throw new DiscordPosterError(
+			"rejected",
+			"editing a card failed: the poster cannot change a message's kind, Components V2 or a preview card",
+			{ discordCode: 50035, status: 400 },
+		);
+}

package/src/core/testing/fake-poster-forum.ts

@@ -0,0 +1,184 @@
+import type {
+	ChannelKindInfo,
+	ForumPost,
+	ForumPostCreated,
+	ForumTag,
+	ForumTagInput,
+} from "../discord/poster/poster.ts";
+import { checkSnowflake } from "../discord/poster/poster-checks.ts";
+import { DiscordPosterError } from "../discord/poster/poster-errors.ts";
+import {
+	checkedForumPost,
+	checkedForumTags,
+	checkedTagIds,
+	forumTakesPosts,
+	notForum,
+	readTag,
+} from "../discord/poster/poster-forum.ts";
+import { cardContent } from "./fake-poster-cards.ts";
+import {
+	type FakePosterChannel,
+	FakePosterGuild,
+} from "./fake-poster-guild.ts";
+
+/** A forum the fake holds: the tags it offers. */
+export interface FakeForum {
+	tags: ForumTag[];
+}
+
+/** The fake's forum calls and `channelKind`, on top of its channel, thread and member calls. */
+export abstract class FakePosterForum extends FakePosterGuild {
+	/**
+	 * The forums that exist, with their tags. A test makes one by setting an entry (and registering
+	 * the channel in `channels`); a post made in a channel that is none fails as `not_forum`.
+	 */
+	readonly forums = new Map<string, FakeForum>();
+
+	#forum(forumId: string): FakeForum {
+		if (this.goneChannels.has(forumId))
+			throw new DiscordPosterError(
+				"channel_gone",
+				"the channel does not exist",
+			);
+		const forum = this.forums.get(forumId);
+		if (forum) return forum;
+		if (this.channels.has(forumId) || this.categories.has(forumId))
+			throw notForum("that channel");
+		throw new DiscordPosterError("channel_gone", "the channel does not exist");
+	}
+
+	/** Discord takes no message straight into a forum: a post is made with `createForumPost`. */
+	protected refuseForum(channelId: string): void {
+		if (this.forums.has(channelId)) throw forumTakesPosts();
+	}
+
+	/** A tag the forum does not offer is Discord's 400. */
+	#offered(forum: FakeForum, tagIds: readonly string[]): void {
+		if (tagIds.some((id) => !forum.tags.some((tag) => tag.id === id)))
+			throw new DiscordPosterError(
+				"rejected",
+				"a tag is not one the forum offers",
+				{ discordCode: 50035, status: 400 },
+			);
+	}
+
+	async channelKind(channelId: string): Promise<ChannelKindInfo> {
+		checkSnowflake("a channel", channelId);
+		this.sent("channelKind");
+		if (this.goneChannels.has(channelId))
+			throw new DiscordPosterError(
+				"channel_gone",
+				"the channel does not exist",
+			);
+		const guildId = this.channelGuilds.get(channelId) ?? this.guildId;
+		if (this.categories.has(channelId)) return { guildId, kind: "category" };
+		const channel = this.channels.get(channelId);
+		if (!channel)
+			throw new DiscordPosterError(
+				"channel_gone",
+				"the channel does not exist",
+			);
+		const parent = channel.parentId ? { parentId: channel.parentId } : {};
+		if (this.forums.has(channelId))
+			return { guildId, kind: "forum", ...parent };
+		if (channel.startedOn !== undefined)
+			return {
+				guildId,
+				kind:
+					channel.parentId && this.forums.has(channel.parentId)
+						? "forum_post"
+						: "thread",
+				...parent,
+			};
+		return { guildId, kind: "text", ...parent };
+	}
+
+	async forumTags(forumId: string): Promise<ForumTag[]> {
+		checkSnowflake("a forum", forumId);
+		this.sent("forumTags");
+		return this.#forum(forumId).tags.map((tag) => ({ ...tag }));
+	}
+
+	async setForumTags(
+		forumId: string,
+		tags: readonly ForumTagInput[],
+	): Promise<ForumTag[]> {
+		checkSnowflake("a forum", forumId);
+		const wire = checkedForumTags(tags);
+		this.sent("setForumTags");
+		const forum = this.#forum(forumId);
+		const next = wire.map((tag) => {
+			if ("id" in tag && !forum.tags.some((held) => held.id === tag.id))
+				throw new DiscordPosterError("rejected", "a tag id is unknown", {
+					discordCode: 50035,
+					status: 400,
+				});
+			let id = "id" in tag ? tag.id : undefined;
+			if (id === undefined) {
+				this.nextChannel += 1n;
+				id = this.nextChannel.toString();
+			}
+			return readTag({ ...tag, id }) as ForumTag;
+		});
+		forum.tags = next;
+		return next.map((tag) => ({ ...tag }));
+	}
+
+	async createForumPost(
+		forumId: string,
+		post: ForumPost,
+	): Promise<ForumPostCreated> {
+		checkSnowflake("a forum", forumId);
+		const checked = checkedForumPost(post);
+		this.sent("createForumPost");
+		const forum = this.#forum(forumId);
+		this.#offered(forum, checked.appliedTags);
+		this.nextChannel += 1n;
+		const id = this.nextChannel.toString();
+		const channel: FakePosterChannel = {
+			name: post.name,
+			parentId: forumId,
+			topic: "",
+			messages: [
+				{
+					id,
+					username: "bot",
+					content: post.card ? cardContent(post.card) : (post.content ?? ""),
+					files: [],
+					blobs: [],
+					mentions: checked.mentions,
+					authorId: this.botId,
+					...(post.card ? { card: post.card } : {}),
+					at: this.tick(),
+				},
+			],
+			pins: [],
+			avatars: new Map(),
+			// The first message of a post has the post's own id.
+			startedOn: id,
+			autoArchiveMinutes: checked.autoArchive,
+			appliedTags: checked.appliedTags,
+		};
+		this.channels.set(id, channel);
+		return { threadId: id, messageId: id };
+	}
+
+	async setPostTags(
+		threadId: string,
+		tagIds: readonly string[],
+	): Promise<void> {
+		checkSnowflake("a thread", threadId);
+		const ids = checkedTagIds(tagIds);
+		this.sent("setPostTags");
+		const channel = this.existing(threadId);
+		const forum =
+			channel.startedOn !== undefined && channel.parentId
+				? this.forums.get(channel.parentId)
+				: undefined;
+		if (!forum) throw notForum("that thread's parent");
+		this.#offered(forum, ids);
+		// The poster sends `archived: false` with the tags, so an archived post is opened again.
+		this.wake(channel);
+		channel.appliedTags = ids;
+	}
+}

package/src/core/testing/fake-poster-guild.ts

@@ -52,6 +52,8 @@ export interface FakePosterChannel {
 	avatars: Map<string, Uint8Array>;
 	/** For a thread: the message of the parent channel it was started on. */
 	startedOn?: string;
+	/** For a forum post: the ids of the tags applied to it. */
+	appliedTags?: string[];
 	/** For a thread: the minutes without a message after which it archives itself. */
 	autoArchiveMinutes?: number;
 	/** For a thread: whether it is archived. A post by the bot wakes it, as on Discord. */
@@ -359,6 +361,8 @@ export abstract class FakePosterGuild {
 				"unavailable",
 				"renaming a channel failed (held back by Discord's rate limit)",
 			);
+		// The poster sends `archived: false` with a thread's name, so an archived thread is opened again.
+		this.wake(channel);
 		this.#renameTimes.set(channelId, [...recent, at]);
 		channel.name = name;
 		this.renames.push([channelId, name]);

package/src/core/testing/fake-poster-reads.ts

@@ -5,10 +5,10 @@ import {
 } from "../discord/poster/poster.ts";
 import { checkSnowflake } from "../discord/poster/poster-checks.ts";
 import { DiscordPosterError } from "../discord/poster/poster-errors.ts";
-import { FakePosterGuild } from "./fake-poster-guild.ts";
+import { FakePosterForum } from "./fake-poster-forum.ts";
 
 /** The fake's pin calls and message reads, on top of its channel, thread and member calls. */
-export abstract class FakePosterReads extends FakePosterGuild {
+export abstract class FakePosterReads extends FakePosterForum {
 	async pin(channelId: string, messageId: string): Promise<void> {
 		checkSnowflake("a channel", channelId);
 		checkSnowflake("a message", messageId);

package/src/core/testing/fake-poster.ts

@@ -14,13 +14,16 @@ import {
 	invalid,
 } from "../discord/poster/poster-checks.ts";
 import { DiscordPosterError } from "../discord/poster/poster-errors.ts";
-import {
-	cardText,
-	type FakePosterChannel,
-	type FakePosterMessage,
+import { archivedThread } from "../discord/poster/poster-forum.ts";
+import { assertSameCardKind, cardContent } from "./fake-poster-cards.ts";
+import type { FakeForum } from "./fake-poster-forum.ts";
+import type {
+	FakePosterChannel,
+	FakePosterMessage,
 } from "./fake-poster-guild.ts";
 import { FakePosterReads } from "./fake-poster-reads.ts";
 
+export type { FakeForum } from "./fake-poster-forum.ts";
 export type {
 	FakePosterChannel,
 	FakePosterMessage,
@@ -44,6 +47,11 @@ export interface FakeDiscordPoster extends DiscordPoster {
 	readonly goneChannels: Set<string>;
 	/** The categories that exist; creating a channel under any other fails as `channel_gone`. */
 	readonly categories: Set<string>;
+	/**
+	 * The forums that exist, with the tags each offers. Make one by setting an entry here and
+	 * registering the channel in `channels`; a forum call on any other channel fails as `not_forum`.
+	 */
+	readonly forums: Map<string, FakeForum>;
 	/** How many channels a category holds (Discord: 50) and a guild holds (Discord: 500). */
 	categoryLimit: number;
 	guildLimit: number;
@@ -155,6 +163,7 @@ class FakePosterImpl extends FakePosterReads implements FakeDiscordPoster {
 		const { webhook, body, files } = checkedPost(post);
 		this.sent("post");
 		const channel = this.channel(channelId);
+		this.refuseForum(channelId);
 		const webhookId = await this.#webhook(channelId, webhook);
 		this.next += 1n;
 		const message: FakePosterMessage = {
@@ -245,7 +254,7 @@ class FakePosterImpl extends FakePosterReads implements FakeDiscordPoster {
 		const message: FakePosterMessage = {
 			id: this.next.toString(),
 			username: body.username,
-			content: cardText(post.card),
+			content: cardContent(post.card),
 			files: [],
 			blobs: [],
 			mentions: [],
@@ -283,8 +292,9 @@ class FakePosterImpl extends FakePosterReads implements FakeDiscordPoster {
 				"editing a card failed: that message is not a card",
 				{ discordCode: 50035, status: 400 },
 			);
+		assertSameCardKind(message.card, card);
 		message.card = card;
-		message.content = cardText(card);
+		message.content = cardContent(card);
 	}
 
 	async remove(
@@ -353,6 +363,7 @@ class FakePosterImpl extends FakePosterReads implements FakeDiscordPoster {
 		const body = checkedText(post.content, post.mentions);
 		this.sent("say");
 		const channel = this.channel(channelId);
+		this.refuseForum(channelId);
 		this.wake(channel);
 		this.next += 1n;
 		channel.messages.push({
@@ -373,12 +384,13 @@ class FakePosterImpl extends FakePosterReads implements FakeDiscordPoster {
 		cardBody(card);
 		this.sent("sayCard");
 		const channel = this.channel(channelId);
+		this.refuseForum(channelId);
 		this.wake(channel);
 		this.next += 1n;
 		channel.messages.push({
 			id: this.next.toString(),
 			username: "bot",
-			content: cardText(card),
+			content: cardContent(card),
 			files: [],
 			blobs: [],
 			mentions: [],
@@ -399,6 +411,13 @@ class FakePosterImpl extends FakePosterReads implements FakeDiscordPoster {
 		cardBody(card);
 		this.sent("editCard");
 		const message = this.found(channelId, messageId);
+		const thread = this.channels.get(channelId);
+		// Discord refuses the edit of a message in an archived thread; the poster opens a post again
+		// for its first message (which has the post's id) and sends the edit once more.
+		if (thread?.archived) {
+			if (channelId !== messageId) throw archivedThread();
+			this.wake(thread);
+		}
 		// A message posted without the Components V2 flag cannot become a card.
 		if (!message.card)
 			throw new DiscordPosterError(
@@ -406,8 +425,9 @@ class FakePosterImpl extends FakePosterReads implements FakeDiscordPoster {
 				"editing a card failed: that message is not a card",
 				{ discordCode: 50035, status: 400 },
 			);
+		assertSameCardKind(message.card, card);
 		message.card = card;
-		message.content = cardText(card);
+		message.content = cardContent(card);
 	}
 
 	async deleteAsBot(channelId: string, messageId: string): Promise<void> {

package/src/discord/index.ts

@@ -84,14 +84,21 @@ export type {
 	CardPicture,
 	CardSelect,
 	CategoryChannel,
+	ChannelKind,
+	ChannelKindInfo,
 	DiscordCard,
 	DiscordFailure,
 	DiscordMessage,
 	DiscordPoster,
 	DiscordReason,
+	ForumPost,
+	ForumPostCreated,
+	ForumTag,
+	ForumTagInput,
 	PostedMessage,
 	PosterFile,
 	RecentMessage,
+	ThreadAutoArchive,
 	ThreadCloser,
 	ThreadState,
 	WebhookCardPost,

package/src/testing.ts

@@ -103,6 +103,7 @@ export {
 export { eagerText, useEagerCatalog } from "./core/testing/eager-catalog.ts";
 export type {
 	FakeDiscordPoster,
+	FakeForum,
 	FakePosterChannel,
 	FakePosterMessage,
 } from "./core/testing/fake-poster.ts";