type DiscordBotConfiguration = {
public_key: string,
application_id: string
};
/**
* Creates a thread in Discord and sends a series of messages to it using the Discord bot configuration.
* The series starts with a firstMessage, followed by the messages array, and ends with a lastMessage.
* Before attempting to create the thread, it validates that all messages (including first and last) are within the character limit.
* If any message exceeds the limit, it throws an error without creating the thread.
* @param discordBotConfigResource Contains the Discord bot configuration necessary for API requests.
* @param channelId The ID of the Discord channel where the thread will be created.
* @param threadName The name of the thread to be created. Must be 100 characters or less.
* @param firstMessage The first message to be sent to the thread. Must be 2000 characters or less.
* @param messages An array of messages to be sent to the thread after the firstMessage and before the lastMessage. Each message must be 2000 characters or less.
* @param lastMessage The last message to be sent to the thread. Must be 2000 characters or less.
* @returns An object indicating the success status of thread creation and each message sent.
* @throws Error if the thread creation or any message sending fails, or if input validations fail.
*/
export async function main(
discordBotConfigResource: DiscordBotConfiguration,
channelId: string,
threadName: string,
firstMessage: string,
messages: string[],
lastMessage: string
): Promise<{ thread: boolean; messages: boolean[] }> {
// First, validate threadName length
if (threadName.length > 100) {
throw new Error("Thread name must be 100 characters or less.");
}
// Validate firstMessage and lastMessage length
if (firstMessage.length > 2000) {
throw new Error("First message must be 2000 characters or less.");
}
if (lastMessage.length > 2000) {
throw new Error("Last message must be 2000 characters or less.");
}
// Next, validate each message length in the array. This ensures all messages are checked before any API request is made.
for (const message of messages) {
if (message.length > 2000) {
throw new Error("Each message must be 2000 characters or less.");
}
}
// Initialize the result object
const result = {
thread: false,
messages: []
};
// Construct the URL for creating a thread
const createThreadUrl = `https://discord.com/api/v9/channels/${channelId}/threads`;
// Prepare the request body for creating a thread
const createThreadBody = JSON.stringify({
name: threadName,
auto_archive_duration: 60, // Automatically archive the thread after 60 minutes of inactivity
type: 11 // Type 11 represents a private thread
});
// Prepare the request headers
const headers = {
'Content-Type': 'application/json',
'Authorization': `Bot ${discordBotConfigResource.public_key}`
};
// Attempt to create the thread by sending a POST request
const createThreadResponse = await fetch(createThreadUrl, {
method: 'POST',
headers: headers,
body: createThreadBody
});
if (!createThreadResponse.ok) {
throw new Error("Failed to create thread");
}
// Parse the response to get the thread ID
const threadInfo = await createThreadResponse.json();
const threadId = threadInfo.id;
result.thread = true; // Mark thread creation as successful
// Function to send a message to the created thread
const sendMessage = async (message: string) => {
// Construct the URL for sending a message to the thread
const sendMessageUrl = `https://discord.com/api/v9/channels/${threadId}/messages`;
// Prepare the request body for sending a message
const messageBody = JSON.stringify({
content: message
});
// Attempt to send the message by sending a POST request
const sendMessageResponse = await fetch(sendMessageUrl, {
method: 'POST',
headers: headers,
body: messageBody
});
// Check for rate limit response before checking if response is OK
if (sendMessageResponse.status === 429) { // 429 is the HTTP status code for Too Many Requests
const retryAfter = parseInt(sendMessageResponse.headers.get('Retry-After'), 10);
console.log(`Rate limit hit, retrying after ${retryAfter} seconds.`);
await new Promise(resolve => setTimeout(resolve, retryAfter * 1000)); // Wait for the duration specified by Retry-After
return sendMessage(message); // Attempt to resend the message
}
if (!sendMessageResponse.ok) {
throw new Error(`Failed to send message: ${message}`);
}
// Record the success status of sending each message
result.messages.push(true);
};
// Send the first message
await sendMessage(firstMessage);
// Send messages in the array
for (const message of messages) {
await sendMessage(message);
}
// Send the last message
await sendMessage(lastMessage);
return result;
}
Submitted by henri186 269 days ago