✨ Update thread name on message updates (#468)

.prettierrc

@@ -2,5 +2,6 @@
 	"useTabs": true,
 	"tabWidth": 4,
 	"arrowParens": "avoid",
-	"printWidth": 120
+	"printWidth": 120,
+	"trailingComma": "all"
 }

src/NeedleBot.ts

@@ -43,7 +43,7 @@ export default class NeedleBot {
 		buttonsService: DynamicImportService<typeof NeedleButton>,
 		modalsService: DynamicImportService<typeof NeedleModal>,
 		configService: ConfigService,
-		cooldownService: CooldownService
+		cooldownService: CooldownService,
 	) {
 		this.client = discordClient;
 
@@ -112,27 +112,27 @@ export default class NeedleBot {
 			const listener = new Class(this);
 
 			if (listener.runType === ListenerRunType.EveryTime) {
-				this.client.on(listener.name, (...args) => {
+				this.client.on(listener.name, async (...args) => {
 					try {
-						listener.handle(args).catch(this.handleError);
+						await listener.handle(args).catch(this.handleError);
 					} catch (e) {
-						console.error(e);
+						this.handleError(e);
 					}
 				});
 			} else if (listener.runType === ListenerRunType.OnlyOnce) {
-				this.client.once(listener.name, (...args) => {
+				this.client.once(listener.name, async (...args) => {
 					try {
-						listener.handle(args).catch(this.handleError);
+						await listener.handle(args).catch(this.handleError);
 					} catch (e) {
-						console.error(e);
+						this.handleError(e);
 					}
 				});
 			}
 		}
 
 		this.client.on("debug", msg => console.log(`[${this.getCurrentTime()}] DEBUG: ${msg}`));
 		this.client.on("shardError", (error, shardId) =>
-			console.log(`[${this.getCurrentTime()}] SHARD ERROR (id ${shardId}): ${error}`)
+			console.log(`[${this.getCurrentTime()}] SHARD ERROR (id ${shardId}): ${error}`),
 		);
 		this.client.on("warn", msg => console.log(`[${this.getCurrentTime()}] WARN: ${msg}`));
 	}

src/eventListeners/messageCreate.ts

@@ -41,7 +41,7 @@ export default class MessageCreateEventListener extends NeedleEventListener {
 		const botMember = await message.guild.members.fetchMe();
 		const guildConfig = this.bot.configs.get(message.guildId);
 		const channelConfig = guildConfig.threadChannels?.find(
-			c => c.channelId === message.channelId || c.channelId === message.channel.parentId
+			c => c.channelId === message.channelId || c.channelId === message.channel.parentId,
 		);
 
 		if (!channelConfig) return;
@@ -61,6 +61,6 @@ export default class MessageCreateEventListener extends NeedleEventListener {
 		const { author, member, channel } = message;
 		const messageVariables = new MessageVariables().setChannel(channel).setUser(member ?? author);
 
-		await this.threadCreator.createThreadOnMessage(message, messageVariables);
+		await this.threadCreator.createOrUpdateThreadOnMessage(message, messageVariables);
 	}
 }

src/eventListeners/messageUpdate.ts

@@ -0,0 +1,51 @@
+import { ClientEvents } from "discord.js";
+import NeedleEventListener from "../models/NeedleEventListener.js";
+import ListenerRunType from "../models/enums/ListenerRunType.js";
+import ThreadCreationService from "../services/ThreadCreationService.js";
+import NeedleBot from "../NeedleBot.js";
+import ObjectFactory from "../ObjectFactory.js";
+import MessageVariables from "../models/MessageVariables.js";
+
+export default class MessageUpdateEventListener extends NeedleEventListener {
+	public readonly name = "messageUpdate";
+	public readonly runType = ListenerRunType.EveryTime;
+
+	private readonly threadCreator: ThreadCreationService;
+
+	constructor(bot: NeedleBot) {
+		super(bot);
+		this.threadCreator = ObjectFactory.createThreadCreationService(true);
+	}
+
+	public async handle([oldMessage, newMessage]: ClientEvents["messageUpdate"]): Promise<void> {
+		await newMessage.fetch();
+
+		if (!newMessage.hasThread) return;
+		if (newMessage.thread?.ownerId !== this.bot.client.user?.id) return;
+		if (!oldMessage.inGuild() || !newMessage.inGuild()) return;
+
+		const guildConfig = this.bot.configs.get(newMessage.guildId);
+		const channelConfig = guildConfig.threadChannels?.find(
+			c => c.channelId === newMessage.channelId || c.channelId === newMessage.channel.parentId,
+		);
+
+		if (!channelConfig) return;
+
+		const oldMessageVariables = new MessageVariables()
+			.setChannel(oldMessage.channel)
+			.setUser(oldMessage.member ?? oldMessage.author)
+			.setThread(oldMessage.thread);
+
+		const newMessageVariables = new MessageVariables()
+			.setChannel(newMessage.channel)
+			.setUser(newMessage.member ?? newMessage.author)
+			.setThread(newMessage.thread);
+
+		const expectedOldName = await this.threadCreator.getThreadName(oldMessage, channelConfig, oldMessageVariables);
+		const actualOldName = oldMessage.thread?.name ?? "";
+		// If the previous title is the default title, do not overwrite it
+		if (expectedOldName !== actualOldName) return;
+
+		await this.threadCreator.createOrUpdateThreadOnMessage(newMessage, newMessageVariables);
+	}
+}

src/eventListeners/ready.ts

@@ -78,8 +78,8 @@ export default class ReadyEventListener extends NeedleEventListener {
 							const messageVariables = new MessageVariables()
 								.setChannel(channel)
 								.setUser(member ?? author);
-							return this.threadCreator.createThreadOnMessage(m, messageVariables);
-						})
+							return this.threadCreator.createOrUpdateThreadOnMessage(m, messageVariables);
+						}),
 					);
 				} catch {
 					continue;

src/services/ThreadCreationService.ts

@@ -74,11 +74,10 @@ export default class ThreadCreationService {
 		return true;
 	}
 
-	public async createThreadOnMessage(
-		message: Message,
+	public async createOrUpdateThreadOnMessage(
+		message: Message<true>,
 		messageVariables: MessageVariables,
 	): Promise<AnyThreadChannel | undefined> {
-		if (!message.inGuild()) return;
 		if (!(message.channel instanceof TextChannel) && !(message.channel instanceof NewsChannel)) return;
 
 		const guildConfig = this.bot.configs.get(message.guildId);
@@ -100,7 +99,14 @@ export default class ThreadCreationService {
 		}
 
 		const name = await this.getThreadName(message, channelConfig, messageVariables);
-		if (message.hasThread) return;
+		if (message.hasThread) {
+			await message.fetch();
+			if (!message.thread || message.thread.name === name) return;
+
+			await message.thread.edit({ name });
+			return;
+		}
+
 		const thread = await message.startThread({
 			name,
 			rateLimitPerUser: channelConfig.slowmode === 0 ? undefined : channelConfig.slowmode,
@@ -145,7 +151,7 @@ export default class ThreadCreationService {
 		this.lastLogTime = currentTime;
 	}
 
-	private async getThreadName(
+	public async getThreadName(
 		message: Message,
 		config: AutothreadChannelConfig,
 		variables: MessageVariables,