@buape/carbon 0.1.0

package/src/structures/GroupDmChannel.ts

@@ -0,0 +1,132 @@
+import {
+	type APIGroupDMChannel,
+	ChannelType,
+	Routes
+} from "discord-api-types/v10"
+import { BaseChannel } from "../abstracts/BaseChannel.js"
+import { Message } from "./Message.js"
+import { User } from "./User.js"
+
+/**
+ * Represents a group DM channel.
+ */
+export class GroupDmChannel extends BaseChannel<ChannelType.GroupDM> {
+	/**
+	 * The name of the channel.
+	 */
+	name?: string | null
+	/**
+	 * The recipients of the channel.
+	 */
+	recipients?: User[]
+	type: ChannelType.GroupDM = ChannelType.GroupDM
+	/**
+	 * The ID of the application that created the channel, if it was created by a bot.
+	 */
+	applicationId?: string | null
+	/**
+	 * The icon hash of the channel.
+	 */
+	icon?: string | null
+	/**
+	 * The ID of the user who created the channel.
+	 */
+	ownerId?: string | null
+	/**
+	 * The ID of the last message sent in the channel.
+	 *
+	 * @remarks
+	 * This might not always resolve to a message. The ID still stays a part of the channel's data, even if the message is deleted.
+	 */
+	lastMessageId?: string | null
+	/**
+	 * Whether the channel is managed by an Oauth2 application.
+	 */
+	managed?: boolean | null
+
+	protected setSpecificData(data: APIGroupDMChannel) {
+		this.name = data.name
+		this.recipients = data.recipients?.map((x) => new User(this.client, x))
+		this.applicationId = data.application_id
+		this.icon = data.icon
+		this.ownerId = data.owner_id
+		this.lastMessageId = data.last_message_id
+		this.managed = data.managed
+	}
+
+	/**
+	 * Get the URL of the channel's icon.
+	 */
+	get iconUrl(): string | null {
+		return this.icon
+			? `https://cdn.discordapp.com/channel-icons/${this.id}/${this.icon}.png`
+			: null
+	}
+
+	/**
+	 * Get the owner of the channel.
+	 */
+	get owner(): User {
+		if (!this.ownerId) throw new Error("Cannot get owner without owner ID")
+		return new User(this.client, this.ownerId)
+	}
+
+	/**
+	 * The last message sent in the channel.
+	 *
+	 * @remarks
+	 * This might not always resolve to a message. The ID still stays a part of the channel's data, even if the message is deleted.
+	 * This will always return a partial message, so you can use {@link Message.fetch} to get the full message data.
+	 *
+	 */
+	get lastMessage() {
+		if (!this.lastMessageId) return null
+		return new Message(this.client, {
+			id: this.lastMessageId,
+			channel_id: this.id
+		})
+	}
+
+	/**
+	 * Set the name of the channel
+	 * @param name The new name of the channel
+	 */
+	async setName(name: string) {
+		await this.client.rest.patch(Routes.channel(this.id), {
+			body: {
+				name
+			}
+		})
+		this.name = name
+	}
+
+	async addRecipient(user: User | string) {
+		await this.client.rest.put(
+			Routes.channelRecipient(
+				this.id,
+				typeof user === "string" ? user : user.id
+			)
+		)
+		if (this.recipients)
+			this.recipients.push(
+				typeof user === "string" ? new User(this.client, user) : user
+			)
+		else
+			this.recipients = [
+				typeof user === "string" ? new User(this.client, user) : user
+			]
+	}
+
+	async removeRecipient(user: User | string) {
+		await this.client.rest.delete(
+			Routes.channelRecipient(
+				this.id,
+				typeof user === "string" ? user : user.id
+			)
+		)
+		if (this.recipients)
+			this.recipients = this.recipients.filter(
+				(x) => x.id !== (typeof user === "string" ? user : user.id)
+			)
+	}
+}

package/src/structures/Guild.ts

@@ -0,0 +1,142 @@
+import {
+	type APIChannel,
+	type APIGuild,
+	type APIRole,
+	type RESTPostAPIGuildRoleJSONBody,
+	Routes
+} from "discord-api-types/v10"
+import { Base } from "../abstracts/Base.js"
+import type { Client } from "../classes/Client.js"
+import { channelFactory } from "../factories/channelFactory.js"
+import { Role } from "./Role.js"
+
+export class Guild extends Base {
+	/**
+	 * The ID of the guild
+	 */
+	id: string
+	/**
+	 * The name of the guild.
+	 */
+	name?: string
+	/**
+	 * The description of the guild.
+	 */
+	description?: string | null
+	/**
+	 * The icon hash of the guild.
+	 * You can use {@link Guild.iconUrl} to get the URL of the icon.
+	 */
+	icon?: string | null
+	/**
+	 * The splash hash of the guild.
+	 * You can use {@link Guild.splashUrl} to get the URL of the splash.
+	 */
+	splash?: string | null
+	/**
+	 * The ID of the owner of the guild.
+	 */
+	ownerId?: string
+
+	/**
+	 * Whether the guild is a partial guild (meaning it does not have all the data).
+	 * If this is true, you should use {@link Guild.fetch} to get the full data of the guild.
+	 */
+	partial: boolean
+
+	private rawData: APIGuild | null = null
+
+	constructor(client: Client, rawDataOrId: APIGuild | string) {
+		super(client)
+		if (typeof rawDataOrId === "string") {
+			this.id = rawDataOrId
+			this.partial = true
+		} else {
+			this.rawData = rawDataOrId
+			this.id = rawDataOrId.id
+			this.partial = false
+			this.setData(rawDataOrId)
+		}
+	}
+
+	private setData(data: typeof this.rawData) {
+		if (!data) throw new Error("Cannot set data without having data... smh")
+		this.rawData = data
+		this.name = data.name
+		this.description = data.description
+		this.icon = data.icon
+		this.splash = data.splash
+		this.ownerId = data.owner_id
+		this.partial = false
+	}
+
+	/**
+	 * Fetch updated data for this guild.
+	 * If the guild is partial, this will fetch all the data for the guild and populate the fields.
+	 * If the guild is not partial, all fields will be updated with new values from Discord.
+	 */
+	async fetch() {
+		const newData = (await this.client.rest.get(
+			Routes.guild(this.id)
+		)) as APIGuild
+		if (!newData) throw new Error(`Guild ${this.id}not found`)
+
+		this.setData(newData)
+	}
+
+	/**
+	 * Leave the guild
+	 */
+	async leave() {
+		return await this.client.rest.delete(Routes.guild(this.id))
+	}
+
+	/**
+	 * Create a role in the guild
+	 */
+	async createRole(data: RESTPostAPIGuildRoleJSONBody) {
+		const role = (await this.client.rest.post(Routes.guildRoles(this.id), {
+			body: {
+				...data
+			}
+		})) as APIRole
+		return new Role(this.client, role)
+	}
+
+	/**
+	 * Get the URL of the guild's icon
+	 */
+	get iconUrl(): string | null {
+		return this.icon
+			? `https://cdn.discordapp.com/icons/${this.id}/${this.icon}.png`
+			: null
+	}
+
+	/**
+	 * Get the URL of the guild's splash
+	 */
+	get splashUrl(): string | null {
+		return this.splash
+			? `https://cdn.discordapp.com/splashes/${this.id}/${this.splash}.png`
+			: null
+	}
+
+	/**
+	 * Get all roles in the guild
+	 */
+	get roles() {
+		const roles = this.rawData?.roles
+		if (!roles) throw new Error("Cannot get roles without having data... smh")
+		return roles.map((role) => new Role(this.client, role))
+	}
+
+	/**
+	 * Fetch a channel from the guild by ID
+	 */
+	async fetchChannel(channelId: string) {
+		const channel = (await this.client.rest.get(
+			Routes.channel(channelId)
+		)) as APIChannel
+		return channelFactory(this.client, channel)
+	}
+}

package/src/structures/GuildAnnouncementChannel.ts

@@ -0,0 +1,20 @@
+import { ChannelType, Routes } from "discord-api-types/v10"
+import { BaseGuildTextChannel } from "../abstracts/BaseGuildTextChannel.js"
+import type { GuildTextChannel } from "./GuildTextChannel.js"
+
+/**
+ * Represents a guild announcement channel.
+ */
+export class GuildAnnouncementChannel extends BaseGuildTextChannel<ChannelType.GuildAnnouncement> {
+	type: ChannelType.GuildAnnouncement = ChannelType.GuildAnnouncement
+	protected setMoreSpecificData() {}
+
+	async follow(targetChannel: GuildTextChannel | string) {
+		await this.client.rest.put(Routes.channelFollowers(this.id), {
+			body: {
+				webhook_channel_id:
+					typeof targetChannel === "string" ? targetChannel : targetChannel.id
+			}
+		})
+	}
+}

package/src/structures/GuildCategoryChannel.ts

@@ -0,0 +1,16 @@
+import type { ChannelType } from "discord-api-types/v10"
+import { BaseGuildChannel } from "../abstracts/BaseGuildChannel.js"
+
+/**
+ * Represents a guild category channel.
+ */
+export class GuildCategoryChannel extends BaseGuildChannel<ChannelType.GuildCategory> {
+	protected setSpecificData() {}
+
+	/**
+	 * You cannot send a message to a category channel, so this method throws an error
+	 */
+	override async send(): Promise<void> {
+		throw new Error("Category channels cannot be sent to")
+	}
+}

package/src/structures/GuildForumChannel.ts

@@ -0,0 +1,20 @@
+import type {
+	APIGuildForumChannel,
+	ChannelType,
+	ForumLayoutType
+} from "discord-api-types/v10"
+import { GuildThreadOnlyChannel } from "../abstracts/GuildThreadOnlyChannel.js"
+
+/**
+ * Represents a guild forum channel.
+ */
+export class GuildForumChannel extends GuildThreadOnlyChannel<ChannelType.GuildForum> {
+	/**
+	 * The default forum layout of the channel.
+	 */
+	defaultForumLayout?: ForumLayoutType
+
+	protected setMoreSpecificData(data: APIGuildForumChannel) {
+		this.defaultForumLayout = data.default_forum_layout
+	}
+}

package/src/structures/GuildMediaChannel.ts

@@ -0,0 +1,13 @@
+import type { ChannelType, ForumLayoutType } from "discord-api-types/v10"
+import { GuildThreadOnlyChannel } from "../abstracts/GuildThreadOnlyChannel.js"
+
+/**
+ * Represents a guild media channel (a forum channel )
+ */
+export class GuildMediaChannel extends GuildThreadOnlyChannel<ChannelType.GuildMedia> {
+	/**
+	 * The default forum layout of the channel.
+	 */
+	defaultForumLayout?: ForumLayoutType
+	protected setMoreSpecificData() {}
+}

package/src/structures/GuildStageOrVoiceChannel.ts

@@ -0,0 +1,46 @@
+import type {
+	APIGuildStageVoiceChannel,
+	APIGuildVoiceChannel,
+	ChannelType,
+	VideoQualityMode
+} from "discord-api-types/v10"
+import { BaseGuildChannel } from "../abstracts/BaseGuildChannel.js"
+
+export abstract class GuildStageOrVoiceChannel<
+	Type extends ChannelType.GuildStageVoice | ChannelType.GuildVoice
+> extends BaseGuildChannel<Type> {
+	/**
+	 * The bitrate of the channel.
+	 */
+	bitrate?: number | null
+	/**
+	 * The user limit of the channel.
+	 */
+	userLimit?: number | null
+	/**
+	 * The RTC region of the channel.
+	 * This is automatic when set to `null`.
+	 */
+	rtcRegion?: string | null
+	/**
+	 * The video quality mode of the channel.
+	 * 1 when not present.
+	 */
+	videoQualityMode?: VideoQualityMode | null
+
+	protected setSpecificData(
+		data: APIGuildStageVoiceChannel | APIGuildVoiceChannel
+	) {
+		this.bitrate = data.bitrate
+		this.userLimit = data.user_limit
+		this.rtcRegion = data.rtc_region
+		this.videoQualityMode = data.video_quality_mode
+	}
+}
+
+export class GuildStageChannel extends BaseGuildChannel<ChannelType.GuildStageVoice> {
+	protected setSpecificData() {}
+}
+export class GuildVoiceChannel extends BaseGuildChannel<ChannelType.GuildVoice> {
+	protected setSpecificData() {}
+}

package/src/structures/GuildTextChannel.ts

@@ -0,0 +1,21 @@
+import { type APIGuildTextChannel, ChannelType } from "discord-api-types/v10"
+import { BaseGuildTextChannel } from "../abstracts/BaseGuildTextChannel.js"
+
+export class GuildTextChannel extends BaseGuildTextChannel<ChannelType.GuildText> {
+	type: ChannelType.GuildText = ChannelType.GuildText
+	/**
+	 * The default auto archive duration of threads in the channel.
+	 */
+	defaultAutoArchiveDuration?: number | null
+	/**
+	 * The default thread rate limit per user of the channel.
+	 */
+	defaultThreadRateLimitPerUser?: number | null
+
+	protected setMoreSpecificData(
+		data: APIGuildTextChannel<ChannelType.GuildText>
+	) {
+		this.defaultAutoArchiveDuration = data.default_auto_archive_duration
+		this.defaultThreadRateLimitPerUser = data.default_thread_rate_limit_per_user
+	}
+}

package/src/structures/GuildThreadChannel.ts

@@ -0,0 +1,150 @@
+import {
+	type APIThreadChannel,
+	Routes,
+	type ThreadChannelType
+} from "discord-api-types/v10"
+import { BaseGuildChannel } from "../abstracts/BaseGuildChannel.js"
+
+export class GuildThreadChannel<
+	Type extends ThreadChannelType
+> extends BaseGuildChannel<Type> {
+	/**
+	 * Whether the thread is archived.
+	 */
+	archived?: boolean
+	/**
+	 * The duration until the thread is auto archived.
+	 */
+	autoArchiveDuration?: number
+	/**
+	 * The timestamp of when the thread was archived.
+	 */
+	archiveTimestamp?: string
+	/**
+	 * Whether the thread is locked.
+	 */
+	locked?: boolean
+	/**
+	 * Whether non-moderators can add other non-moderators to a thread; only available on private threads
+	 */
+	invitable?: boolean
+	/**
+	 * The timestamp of when the thread was created.
+	 */
+	createTimestamp?: string
+	/**
+	 * The number of messages in the thread.
+	 */
+	messageCount?: number
+	/**
+	 * The number of members in the thread.
+	 *
+	 * @remarks
+	 * This is only accurate until 50, after that, Discord stops counting.
+	 */
+	memberCount?: number
+	/**
+	 * The ID of the owner of the thread.
+	 */
+	ownerId?: string
+	/**
+	 * The number of messages sent in the thread.
+	 */
+	totalMessageSent?: number
+	/**
+	 * The tags applied to the thread.
+	 */
+	appliedTags?: string[]
+
+	protected setSpecificData(data: APIThreadChannel) {
+		this.archived = data.thread_metadata?.archived
+		this.autoArchiveDuration = data.thread_metadata?.auto_archive_duration
+		this.archiveTimestamp = data.thread_metadata?.archive_timestamp
+		this.locked = data.thread_metadata?.locked
+		this.invitable = data.thread_metadata?.invitable
+		this.createTimestamp = data.thread_metadata?.create_timestamp
+		this.messageCount = data.message_count
+		this.memberCount = data.member_count
+		this.ownerId = data.owner_id
+		this.totalMessageSent = data.total_message_sent
+		this.appliedTags = data.applied_tags
+	}
+
+	/**
+	 * Join the thread
+	 */
+	async join() {
+		await this.addMember("@me")
+	}
+
+	/**
+	 * Add a member to the thread
+	 */
+	async addMember(userId: string) {
+		await this.client.rest.put(Routes.threadMembers(this.id, userId))
+	}
+
+	/**
+	 * Leave the thread
+	 */
+	async leave() {
+		await this.removeMember("@me")
+	}
+
+	/**
+	 * Get the pinned messages in the thread
+	 */
+	async removeMember(userId: string) {
+		await this.client.rest.delete(Routes.threadMembers(this.id, userId))
+	}
+
+	/**
+	 * Archive the thread
+	 */
+	async archive() {
+		await this.client.rest.patch(Routes.channel(this.id), {
+			body: { archive: true }
+		})
+		this.archived = true
+	}
+
+	/**
+	 * Unarchive the thread
+	 */
+	async unarchive() {
+		await this.client.rest.patch(Routes.channel(this.id), {
+			body: { archive: false }
+		})
+		this.archived = false
+	}
+
+	/**
+	 * Set the auto archive duration of the thread
+	 */
+	async setAutoArchiveDuration(duration: number) {
+		await this.client.rest.patch(Routes.channel(this.id), {
+			body: { auto_archive_duration: duration }
+		})
+		this.autoArchiveDuration = duration
+	}
+
+	/**
+	 * Lock the thread
+	 */
+	async lock() {
+		await this.client.rest.put(Routes.channel(this.id), {
+			body: { locked: true }
+		})
+		this.locked = true
+	}
+
+	/**
+	 * Unlock the thread
+	 */
+	async unlock() {
+		await this.client.rest.put(Routes.channel(this.id), {
+			body: { locked: false }
+		})
+		this.locked = false
+	}
+}

package/src/structures/Message.ts

@@ -0,0 +1,124 @@
+import {
+	type APIChannel,
+	type APIMessage,
+	type APIThreadChannel,
+	type RESTPostAPIChannelThreadsJSONBody,
+	Routes
+} from "discord-api-types/v10"
+import { Base } from "../abstracts/Base.js"
+import type { Client } from "../classes/Client.js"
+import { channelFactory } from "../factories/channelFactory.js"
+import { GuildThreadChannel } from "./GuildThreadChannel.js"
+import { User } from "./User.js"
+
+export class Message extends Base {
+	/**
+	 * The ID of the message
+	 */
+	id: string
+	/**
+	 * The ID of the channel the message is in
+	 */
+	channelId: string
+	/**
+	 * Whether the message is a partial message (meaning it does not have all the data).
+	 * If this is true, you should use {@link Message.fetch} to get the full data of the message.
+	 */
+	partial: boolean
+
+	private rawData: APIMessage | null = null
+
+	constructor(
+		client: Client,
+		rawDataOrIds:
+			| APIMessage
+			| {
+					id: string
+					channel_id: string
+			  }
+	) {
+		super(client)
+		this.id = rawDataOrIds.id
+		this.channelId = rawDataOrIds.channel_id
+		if (Object.keys(rawDataOrIds).length === 2) {
+			this.partial = true
+		} else {
+			this.partial = false
+			this.setData(rawDataOrIds as APIMessage)
+		}
+	}
+
+	private setData(data: typeof this.rawData) {
+		this.rawData = data
+		if (!data) throw new Error("Cannot set data without having data... smh")
+	}
+
+	/**
+	 * Fetch updated data for this message.
+	 * If the message is partial, this will fetch all the data for the message and populate the fields.
+	 * If the message is not partial, all fields will be updated with new values from Discord.
+	 */
+	async fetch() {
+		const newData = (await this.client.rest.get(
+			Routes.channelMessage(this.channelId, this.id)
+		)) as APIMessage
+		if (!newData) throw new Error(`Message ${this.id} not found`)
+
+		this.setData(newData)
+	}
+
+	/**
+	 * Delete this message from Discord
+	 */
+	async delete() {
+		return await this.client.rest.delete(
+			Routes.channelMessage(this.channelId, this.id)
+		)
+	}
+
+	get author(): User | null {
+		if (this.rawData?.webhook_id) return null // TODO: Add webhook user
+		// Check if we have an additional property on the author object, in which case we have a full user object
+		if (this.rawData?.author.username)
+			return new User(this.client, this.rawData.author)
+		// This means we only have a partial user object
+		if (this.rawData?.author.id)
+			return new User(this.client, this.rawData.author.id)
+		return null
+	}
+
+	async fetchChannel() {
+		const data = (await this.client.rest.get(
+			Routes.channel(this.channelId)
+		)) as APIChannel
+		return channelFactory(this.client, data)
+	}
+
+	/**
+	 * Pin this message
+	 */
+	async pin() {
+		await this.client.rest.put(Routes.channelPin(this.channelId, this.id))
+	}
+
+	/**
+	 * Unpin this message
+	 */
+	async unpin() {
+		await this.client.rest.delete(Routes.channelPin(this.channelId, this.id))
+	}
+
+	/**
+	 * Start a thread with this message as the associated start message.
+	 * If you want to start a thread without a start message, use {@link BaseGuildTextChannel.startThread}
+	 */
+	async startThread(data: RESTPostAPIChannelThreadsJSONBody) {
+		const thread = (await this.client.rest.post(
+			Routes.threads(this.channelId, this.id),
+			{
+				body: { ...data }
+			}
+		)) as APIThreadChannel
+		return new GuildThreadChannel(this.client, thread)
+	}
+}