Merge branch 'tiramisulabs:main' into main

src/cache/resources/bans.ts

@@ -22,6 +22,10 @@ export class Bans extends GuildBasedResource<any, GatewayGuildBanModifyDispatchD
 		);
 	}
 
+	raw(id: string, guild: string): ReturnCache<Omit<GatewayGuildBanModifyDispatchData | APIBan, 'user'> | undefined> {
+		return super.get(id, guild);
+	}
+
 	override bulk(ids: string[], guild: string): ReturnCache<GuildBanStructure[]> {
 		return fakePromise(super.bulk(ids, guild)).then(
 			bans =>
@@ -33,6 +37,16 @@ export class Bans extends GuildBasedResource<any, GatewayGuildBanModifyDispatchD
 		);
 	}
 
+	bulkRaw(ids: string[], guild: string): ReturnCache<Omit<GatewayGuildBanModifyDispatchData | APIBan, 'user'>[]> {
+		return fakePromise(super.bulk(ids, guild)).then(bans =>
+			bans
+				.map(rawBan => {
+					return rawBan;
+				})
+				.filter(Boolean),
+		);
+	}
+
 	override values(guild: string): ReturnCache<GuildBanStructure[]> {
 		return fakePromise(super.values(guild)).then(
 			bans =>
@@ -43,4 +57,14 @@ export class Bans extends GuildBasedResource<any, GatewayGuildBanModifyDispatchD
 					.filter(Boolean) as GuildBanStructure[],
 		);
 	}
+
+	valuesRaw(guild: string): ReturnCache<Omit<GatewayGuildBanModifyDispatchData | APIBan, 'user'>[]> {
+		return fakePromise(super.values(guild)).then(bans =>
+			bans
+				.map(rawBan => {
+					return rawBan;
+				})
+				.filter(Boolean),
+		);
+	}
 }

src/cache/resources/channels.ts

@@ -13,25 +13,33 @@ export class Channels extends GuildRelatedResource<any, APIChannel> {
 		return rest;
 	}
 
-	raw(id: string): ReturnCache<APIChannel | undefined> {
-		return super.get(id);
-	}
-
 	override get(id: string): ReturnCache<AllChannels | undefined> {
 		return fakePromise(super.get(id)).then(rawChannel =>
 			rawChannel ? channelFrom(rawChannel, this.client) : undefined,
 		);
 	}
 
+	raw(id: string): ReturnCache<Omit<APIChannel, 'permission_overwrites'> | undefined> {
+		return super.get(id);
+	}
+
 	override bulk(ids: string[]): ReturnCache<ReturnType<typeof channelFrom>[]> {
 		return fakePromise(super.bulk(ids)).then(channels =>
 			channels.map(rawChannel => channelFrom(rawChannel, this.client)),
 		);
 	}
 
+	bulkRaw(ids: string[]): ReturnCache<Omit<APIChannel, 'permission_overwrites'>[]> {
+		return fakePromise(super.bulk(ids)).then(channels => channels.map(rawChannel => rawChannel));
+	}
+
 	override values(guild: string): ReturnCache<ReturnType<typeof channelFrom>[]> {
 		return fakePromise(super.values(guild)).then(channels =>
 			channels.map(rawChannel => channelFrom(rawChannel, this.client)),
 		);
 	}
+
+	valuesRaw(guild: string): ReturnCache<Omit<APIChannel, 'permission_overwrites'>[]> {
+		return fakePromise(super.values(guild)).then(channels => channels.map(rawChannel => rawChannel));
+	}
 }

src/cache/resources/emojis.ts

@@ -18,15 +18,27 @@ export class Emojis extends GuildRelatedResource<any, APIEmoji> {
 		);
 	}
 
+	raw(id: string): ReturnCache<APIEmoji | undefined> {
+		return super.get(id);
+	}
+
 	override bulk(ids: string[]): ReturnCache<GuildEmojiStructure[]> {
 		return fakePromise(super.bulk(ids) as (APIEmoji & { id: string; guild_id: string })[]).then(emojis =>
 			emojis.map(rawEmoji => Transformers.GuildEmoji(this.client, rawEmoji, rawEmoji.guild_id)),
 		);
 	}
 
+	bulkRaw(ids: string[]): ReturnCache<(APIEmoji & { id: string; guild_id: string })[]> {
+		return super.bulk(ids);
+	}
+
 	override values(guild: string): ReturnCache<GuildEmojiStructure[]> {
 		return fakePromise(super.values(guild) as (APIEmoji & { id: string; guild_id: string })[]).then(emojis =>
 			emojis.map(rawEmoji => Transformers.GuildEmoji(this.client, rawEmoji, rawEmoji.guild_id)),
 		);
 	}
+
+	valuesRaw(guild: string): ReturnCache<(APIEmoji & { id: string; guild_id: string })[]> {
+		return super.values(guild);
+	}
 }

src/cache/resources/guilds.ts

@@ -12,28 +12,36 @@ export class Guilds extends BaseResource<any, APIGuild | GatewayGuildCreateDispa
 		return true;
 	}
 
-	raw(id: string): ReturnCache<APIGuild | undefined> {
-		return super.get(id);
-	}
-
 	override get(id: string): ReturnCache<GuildStructure<'cached'> | undefined> {
 		return fakePromise(super.get(id)).then(guild =>
 			guild ? Transformers.Guild<'cached'>(this.client, guild) : undefined,
 		);
 	}
 
+	raw(id: string): ReturnCache<APIGuild | undefined> {
+		return super.get(id);
+	}
+
 	override bulk(ids: string[]): ReturnCache<GuildStructure<'cached'>[]> {
 		return fakePromise(super.bulk(ids) as APIGuild[]).then(guilds =>
 			guilds.map(x => Transformers.Guild<'cached'>(this.client, x)),
 		);
 	}
 
+	bulkRaw(ids: string[]): ReturnCache<APIGuild[]> {
+		return super.bulk(ids);
+	}
+
 	override values(): ReturnCache<GuildStructure<'cached'>[]> {
 		return fakePromise(super.values() as APIGuild[]).then(guilds =>
 			guilds.map(x => Transformers.Guild<'cached'>(this.client, x)),
 		);
 	}
 
+	valuesRaw(): ReturnCache<APIGuild[]> {
+		return super.values();
+	}
+
 	override async remove(id: string) {
 		const keysChannels = this.cache.channels?.keys(id) ?? [];
 		await this.cache.adapter.bulkRemove(

src/cache/resources/members.ts

@@ -16,6 +16,14 @@ export class Members extends GuildBasedResource<any, APIGuildMember> {
 		return rest;
 	}
 
+	override get(id: string, guild: string): ReturnCache<GuildMemberStructure | undefined> {
+		return fakePromise(super.get(id, guild)).then(rawMember =>
+			fakePromise(this.client.cache.users?.raw(id)).then(user =>
+				rawMember && user ? Transformers.GuildMember(this.client, rawMember, user, guild) : undefined,
+			),
+		);
+	}
+
 	raw(id: string, guild: string): ReturnCache<APIGuildMember | undefined> {
 		return fakePromise(super.get(id, guild) as Omit<APIGuildMember, 'user'>).then(rawMember => {
 			return fakePromise(this.client.cache.users?.raw(id)).then(user =>
@@ -29,14 +37,6 @@ export class Members extends GuildBasedResource<any, APIGuildMember> {
 		});
 	}
 
-	override get(id: string, guild: string): ReturnCache<GuildMemberStructure | undefined> {
-		return fakePromise(super.get(id, guild)).then(rawMember =>
-			fakePromise(this.client.cache.users?.raw(id)).then(user =>
-				rawMember && user ? Transformers.GuildMember(this.client, rawMember, user, guild) : undefined,
-			),
-		);
-	}
-
 	override bulk(ids: string[], guild: string): ReturnCache<GuildMemberStructure[]> {
 		return fakePromise(super.bulk(ids, guild)).then(members =>
 			fakePromise(this.client.cache.users?.bulkRaw(ids)).then(
@@ -51,6 +51,10 @@ export class Members extends GuildBasedResource<any, APIGuildMember> {
 		);
 	}
 
+	bulkRaw(ids: string[], guild: string): ReturnCache<Omit<APIGuildMember, 'user'>[]> {
+		return super.bulk(ids, guild);
+	}
+
 	override values(guild: string): ReturnCache<GuildMemberStructure[]> {
 		return fakePromise(super.values(guild)).then(members =>
 			fakePromise(this.client.cache.users?.valuesRaw()).then(
@@ -65,6 +69,10 @@ export class Members extends GuildBasedResource<any, APIGuildMember> {
 		);
 	}
 
+	valuesRaw(guild: string): ReturnCache<Omit<APIGuildMember, 'user'>[]> {
+		return super.values(guild);
+	}
+
 	override async set(memberId: string, guildId: string, data: any): Promise<void>;
 	override async set(memberId_dataArray: [string, any][], guildId: string): Promise<void>;
 	override async set(__keys: string | [string, any][], guild: string, data?: any) {

src/cache/resources/messages.ts

@@ -31,6 +31,10 @@ export class Messages extends GuildRelatedResource<any, APIMessage> {
 		});
 	}
 
+	raw(id: string): ReturnCache<APIMessageResource | undefined> {
+		return super.get(id);
+	}
+
 	override bulk(ids: string[]): ReturnCache<MessageStructure[]> {
 		return fakePromise(super.bulk(ids) as APIMessageResource[]).then(
 			messages =>
@@ -48,6 +52,10 @@ export class Messages extends GuildRelatedResource<any, APIMessage> {
 		);
 	}
 
+	bulkRaw(ids: string[]): ReturnCache<APIMessageResource[]> {
+		return super.bulk(ids);
+	}
+
 	override values(channel: string): ReturnCache<MessageStructure[]> {
 		return fakePromise(super.values(channel) as APIMessageResource[]).then(messages => {
 			const hashes: (string | undefined)[] = this.cache.users
@@ -64,9 +72,13 @@ export class Messages extends GuildRelatedResource<any, APIMessage> {
 		});
 	}
 
+	valuesRaw(channel: string): ReturnCache<APIMessageResource[]> {
+		return super.values(channel);
+	}
+
 	keys(channel: string) {
 		return super.keys(channel);
 	}
 }
 
-export type APIMessageResource = Omit<APIMessage, 'author'> & { user_id?: string };
+export type APIMessageResource = Omit<APIMessage, 'author' | 'member'> & { user_id?: string };

src/cache/resources/overwrites.ts

@@ -19,7 +19,7 @@ export class Overwrites extends GuildRelatedResource<any, APIOverwrite[]> {
 		return data;
 	}
 
-	raw(id: string): ReturnCache<(APIOverwrite & { guild_id: string })[]> {
+	raw(id: string): ReturnCache<(APIOverwrite & { guild_id: string })[] | undefined> {
 		return super.get(id);
 	}
 
@@ -59,6 +59,10 @@ export class Overwrites extends GuildRelatedResource<any, APIOverwrite[]> {
 		);
 	}
 
+	valuesRaw(guild: string): ReturnCache<(APIOverwrite & { guild_id: string })[][]> {
+		return super.values(guild);
+	}
+
 	override bulk(
 		ids: string[],
 	): ReturnCache<{ type: number; id: string; deny: PermissionsBitField; allow: PermissionsBitField }[][]> {
@@ -74,4 +78,8 @@ export class Overwrites extends GuildRelatedResource<any, APIOverwrite[]> {
 			),
 		);
 	}
+
+	bulkRaw(ids: string[]): ReturnCache<(APIOverwrite & { guild_id: string })[][]> {
+		return super.bulk(ids);
+	}
 }

src/cache/resources/roles.ts

@@ -12,22 +12,26 @@ export class Roles extends GuildRelatedResource<any, APIRole> {
 		return true;
 	}
 
-	raw(id: string): ReturnCache<APIRole | undefined> {
-		return super.get(id);
-	}
-
 	override get(id: string): ReturnCache<GuildRoleStructure | undefined> {
 		return fakePromise(super.get(id)).then(rawRole =>
 			rawRole ? Transformers.GuildRole(this.client, rawRole, rawRole.guild_id) : undefined,
 		);
 	}
 
+	raw(id: string): ReturnCache<APIRole | undefined> {
+		return super.get(id);
+	}
+
 	override bulk(ids: string[]): ReturnCache<GuildRoleStructure[]> {
 		return fakePromise(super.bulk(ids)).then(roles =>
 			roles.map(rawRole => Transformers.GuildRole(this.client, rawRole, rawRole.guild_id)),
 		);
 	}
 
+	bulkRaw(ids: string[]): ReturnCache<APIRole[]> {
+		return super.bulk(ids);
+	}
+
 	override values(guild: string): ReturnCache<GuildRoleStructure[]> {
 		return fakePromise(super.values(guild)).then(roles =>
 			roles.map(rawRole => Transformers.GuildRole(this.client, rawRole, rawRole.guild_id)),

src/cache/resources/stickers.ts

@@ -18,15 +18,27 @@ export class Stickers extends GuildRelatedResource<any, APISticker> {
 		);
 	}
 
+	raw(id: string): ReturnCache<APISticker | undefined> {
+		return super.get(id);
+	}
+
 	override bulk(ids: string[]): ReturnCache<StickerStructure[]> {
 		return fakePromise(super.bulk(ids) as APISticker[]).then(emojis =>
 			emojis.map(rawSticker => Transformers.Sticker(this.client, rawSticker)),
 		);
 	}
 
+	bulkRaw(ids: string[]): ReturnCache<APISticker[]> {
+		return super.bulk(ids);
+	}
+
 	override values(guild: string): ReturnCache<StickerStructure[]> {
 		return fakePromise(super.values(guild) as APISticker[]).then(emojis =>
 			emojis.map(rawSticker => Transformers.Sticker(this.client, rawSticker)),
 		);
 	}
+
+	valuesRaw(guild: string): ReturnCache<APISticker[]> {
+		return super.values(guild);
+	}
 }

src/cache/resources/threads.ts

@@ -18,15 +18,27 @@ export class Threads extends GuildRelatedResource<any, APIThreadChannel> {
 		);
 	}
 
+	raw(id: string): ReturnCache<APIThreadChannel | undefined> {
+		return super.get(id);
+	}
+
 	override bulk(ids: string[]): ReturnCache<ThreadChannelStructure[]> {
 		return fakePromise(super.bulk(ids) as APIThreadChannel[]).then(threads =>
 			threads.map(rawThread => Transformers.ThreadChannel(this.client, rawThread)),
 		);
 	}
 
+	bulkRaw(ids: string[]): ReturnCache<APIThreadChannel[]> {
+		return super.bulk(ids);
+	}
+
 	override values(guild: string): ReturnCache<ThreadChannelStructure[]> {
 		return fakePromise(super.values(guild) as APIThreadChannel[]).then(threads =>
 			threads.map(rawThread => Transformers.ThreadChannel(this.client, rawThread)),
 		);
 	}
+
+	valuesRaw(guild: string): ReturnCache<APIThreadChannel[]> {
+		return super.values(guild);
+	}
 }

src/cache/resources/users.ts

@@ -12,14 +12,14 @@ export class Users extends BaseResource<any, APIUser> {
 		return true;
 	}
 
-	raw(id: string): ReturnCache<APIUser | undefined> {
-		return super.get(id);
-	}
-
 	override get(id: string): ReturnCache<UserStructure | undefined> {
 		return fakePromise(super.get(id)).then(rawUser => (rawUser ? Transformers.User(this.client, rawUser) : undefined));
 	}
 
+	raw(id: string): ReturnCache<APIUser | undefined> {
+		return super.get(id);
+	}
+
 	override bulk(ids: string[]): ReturnCache<UserStructure[]> {
 		return fakePromise(super.bulk(ids) as APIUser[]).then(users =>
 			users.map(rawUser => Transformers.User(this.client, rawUser)),

src/cache/resources/voice-states.ts

@@ -23,6 +23,10 @@ export class VoiceStates extends GuildBasedResource<any, GatewayVoiceState> {
 		);
 	}
 
+	raw(memberId: string, guildId: string): ReturnCache<GatewayVoiceState | undefined> {
+		return super.get(memberId, guildId);
+	}
+
 	override bulk(ids: string[], guild: string): ReturnCache<VoiceStateStructure[]> {
 		return fakePromise(super.bulk(ids, guild)).then(
 			states =>
@@ -32,11 +36,19 @@ export class VoiceStates extends GuildBasedResource<any, GatewayVoiceState> {
 		);
 	}
 
+	bulkRaw(ids: string[], guild: string): ReturnCache<GatewayVoiceState[]> {
+		return super.bulk(ids, guild);
+	}
+
 	override values(guildId: string): ReturnCache<VoiceStateStructure[]> {
 		return fakePromise(super.values(guildId)).then(states =>
 			states.map(state => Transformers.VoiceState(this.client, state)),
 		);
 	}
+
+	valuesRaw(guildId: string): ReturnCache<GatewayVoiceState[]> {
+		return super.values(guildId);
+	}
 }
 
 export type VoiceStateResource = Omit<GatewayVoiceState, 'member'> & { guild_id: string };

src/commands/handle.ts

@@ -461,20 +461,28 @@ export class HandleCommand {
 		return false;
 	}
 
-	async fetchChannel(_option: CommandOptionWithType, id: string) {
-		return this.client.channels.raw(id);
+	async fetchChannel(_option: CommandOptionWithType, query: string) {
+		const id = query.match(/[0-9]{17,19}/g)?.[0];
+		if (id) return this.client.channels.raw(id);
+		return null;
 	}
 
-	async fetchUser(_option: CommandOptionWithType, id: string) {
-		return this.client.users.raw(id);
+	async fetchUser(_option: CommandOptionWithType, query: string) {
+		const id = query.match(/[0-9]{17,19}/g)?.[0];
+		if (id) return this.client.users.raw(id);
+		return null;
 	}
 
-	async fetchMember(_option: CommandOptionWithType, id: string, guildId: string) {
-		return this.client.members.raw(guildId, id);
+	async fetchMember(_option: CommandOptionWithType, query: string, guildId: string) {
+		const id = query.match(/[0-9]{17,19}/g)?.[0];
+		if (id) return this.client.members.raw(guildId, id);
+		return null;
 	}
 
-	async fetchRole(_option: CommandOptionWithType, id: string, guildId?: string) {
-		return guildId ? (await this.client.roles.listRaw(guildId)).find(x => x.id === id) : undefined;
+	async fetchRole(_option: CommandOptionWithType, query: string, guildId?: string) {
+		const id = query.match(/[0-9]{17,19}/g)?.[0];
+		if (id && guildId) return (await this.client.roles.listRaw(guildId)).find(x => x.id === id);
+		return null;
 	}
 
 	async runGlobalMiddlewares(
@@ -585,11 +593,12 @@ export class HandleCommand {
 						break;
 					case ApplicationCommandOptionType.Channel:
 						{
-							const rawId =
+							const rawQuery =
 								message.content.match(/(?<=<#)[0-9]{17,19}(?=>)/g)?.find(x => args[i.name]?.includes(x)) ||
-								args[i.name]?.match(/[0-9]{17,19}/g)?.[0];
-							if (!rawId) continue;
-							const channel = (await this.client.cache.channels?.raw(rawId)) ?? (await this.fetchChannel(i, rawId));
+								args[i.name];
+							if (!rawQuery) continue;
+							const channel =
+								(await this.client.cache.channels?.raw(rawQuery)) ?? (await this.fetchChannel(i, rawQuery));
 							if (channel) {
 								if ('channel_types' in i) {
 									if (!(i as SeyfertChannelOption).channel_types!.includes(channel.type)) {
@@ -603,15 +612,15 @@ export class HandleCommand {
 										break;
 									}
 								}
-								value = rawId;
+								value = channel.id;
 								//discord funny memoentnt!!!!!!!!
-								resolved.channels[rawId] = channel as APIInteractionDataResolvedChannel;
+								resolved.channels[channel.id] = channel as APIInteractionDataResolvedChannel;
 							}
 						}
 						break;
 					case ApplicationCommandOptionType.Mentionable:
 						{
-							const matches = message.content.match(/<@[0-9]{17,19}(?=>)|<@&[0-9]{17,19}(?=>)/g) ?? [];
+							const matches = args[i.name]?.match(/<@[0-9]{17,19}(?=>)|<@&[0-9]{17,19}(?=>)/g) ?? [];
 							for (const match of matches) {
 								if (match.includes('&')) {
 									const rawId = match.slice(3);
@@ -640,36 +649,33 @@ export class HandleCommand {
 						break;
 					case ApplicationCommandOptionType.Role:
 						{
-							const rawId =
-								message.mention_roles.find(x => args[i.name]?.includes(x)) || args[i.name]?.match(/[0-9]{17,19}/g)?.[0];
-							if (!rawId) continue;
+							const rawQuery = message.mention_roles.find(x => args[i.name]?.includes(x)) || args[i.name];
+							if (!rawQuery) continue;
 							const role =
-								(await this.client.cache.roles?.raw(rawId)) ?? (await this.fetchRole(i, rawId, message.guild_id));
+								(await this.client.cache.roles?.raw(rawQuery)) ?? (await this.fetchRole(i, rawQuery, message.guild_id));
 							if (role) {
-								value = rawId;
-								resolved.roles[rawId] = role;
+								value = role.id;
+								resolved.roles[role.id] = role;
 							}
 						}
 						break;
 					case ApplicationCommandOptionType.User:
 						{
-							const rawId =
-								message.mentions.find(x => args[i.name]?.includes(x.id))?.id ||
-								args[i.name]?.match(/[0-9]{17,19}/g)?.[0];
-							if (!rawId) continue;
+							const rawQuery = message.mentions.find(x => args[i.name]?.includes(x.id))?.id || args[i.name];
+							if (!rawQuery) continue;
 							const raw =
 								message.mentions.find(x => args[i.name]?.includes(x.id)) ??
-								(await this.client.cache.users?.raw(rawId)) ??
-								(await this.fetchUser(i, rawId));
+								(await this.client.cache.users?.raw(rawQuery)) ??
+								(await this.fetchUser(i, rawQuery));
 							if (raw) {
 								value = raw.id;
 								resolved.users[raw.id] = raw;
 								if (message.guild_id) {
 									const member =
 										message.mentions.find(x => args[i.name]?.includes(x.id))?.member ??
-										(await this.client.cache.members?.raw(rawId, message.guild_id)) ??
-										(await this.fetchMember(i, rawId, message.guild_id));
-									if (member) resolved.members[raw.id] = member;
+										(await this.client.cache.members?.raw(value, message.guild_id)) ??
+										(await this.fetchMember(i, value, message.guild_id));
+									if (member) resolved.members[value] = member;
 								}
 							}
 						}

src/common/shorters/channels.ts

@@ -5,6 +5,8 @@ import {
 	type RESTPatchAPIChannelJSONBody,
 	type RESTPostAPIChannelThreadsJSONBody,
 	type RESTPostAPIGuildForumThreadsJSONBody,
+	type ChannelType,
+	type APIGuildChannel,
 } from 'discord-api-types/v10';
 import { BaseChannel, type GuildRole, type GuildMember } from '../../structures';
 import channelFrom, { type AllChannels } from '../../structures/channels';
@@ -29,7 +31,11 @@ export class ChannelShorter extends BaseShorter {
 		let channel;
 		if (!force) {
 			channel = await this.client.cache.channels?.raw(id);
-			if (channel) return channel;
+			const overwrites = await this.client.cache.overwrites?.raw(id);
+			if (channel) {
+				if (overwrites) (channel as APIGuildChannel<ChannelType>).permission_overwrites = overwrites;
+				return channel as APIChannel;
+			}
 		}
 
 		channel = await this.client.proxy.channels(id).get();