yuzuha 0.2.0 → 0.3.0

package/src/infrastructure/fluxer/resources/collectors.ts

@@ -1,7 +1,10 @@
 import type { Client, Message } from '@fluxerjs/core';
 import { MessageCollector, ReactionCollector } from '@fluxerjs/core';
-import type { AwaitMessageInput, CollectedMessageInfo, CollectorsResources, ReactionVote } from '../../../ports/resources/collectors.js';
+import type { AwaitMessageInput, CollectedMessageInfo, CollectMessagesInput, CollectReactionsInput, CollectorsResources, ReactionVote } from '../../../ports/resources/collectors.js';
 import { cancellationError } from '../../../services/cancellation.js';
+import { YuzuhaError } from '../../../errors.js';
+
+type ReactionLike = { emojiIdentifier: string; emoji: { name: string }; messageId: string };
 
 function info(message: Message): CollectedMessageInfo {
   return { id: message.id, channelID: message.channelId, authorID: message.author.id, content: message.content };
@@ -11,11 +14,47 @@ function targets(emojis: string | string[]): string[] {
   return (Array.isArray(emojis) ? emojis : [emojis]).map(value => value.trim().toLowerCase()).filter(Boolean);
 }
 
-function vote(reaction: { emojiIdentifier: string; emoji: { name: string } }, userID: string, wanted: string[]): ReactionVote | null {
+function matches(reaction: ReactionLike, wanted: string[]): boolean {
   const identifier = reaction.emojiIdentifier.toLowerCase();
   const name = reaction.emoji.name.toLowerCase();
-  if (!wanted.includes(identifier) && !wanted.includes(name)) return null;
-  return { userID, emoji: reaction.emoji.name };
+  return wanted.includes(identifier) || wanted.includes(name);
+}
+
+function voteInfo(reaction: ReactionLike, userID: string): ReactionVote {
+  return { userID, emoji: reaction.emoji.name, messageID: reaction.messageId };
+}
+
+function vote(reaction: ReactionLike, userID: string, wanted: string[]): ReactionVote | null {
+  return matches(reaction, wanted) ? voteInfo(reaction, userID) : null;
+}
+
+function positiveBound(value: number | undefined): number {
+  return value !== undefined && Number.isFinite(value) && value > 0 ? value : 0;
+}
+
+function requireBounds(time: number, max: number, signal: AbortSignal | undefined): void {
+  if (time <= 0 && max <= 0 && signal === undefined) {
+    throw new YuzuhaError('COLLECTOR_BOUNDS', 'Informe um limite para o coletor: timeMs, max ou signal.');
+  }
+}
+
+/** Itera itens de um coletor do SDK: enfileira 'collect', encerra no 'end' e limpa ao sair. */
+async function* pump<T>(attach: (push: (item: T) => void, finish: () => void) => () => void): AsyncGenerator<T, void> {
+  const queue: T[] = [];
+  let ended = false;
+  let waiting: (() => void) | undefined;
+  const notify = (): void => { const wake = waiting; waiting = undefined; wake?.(); };
+  const detach = attach(item => { queue.push(item); notify(); }, () => { ended = true; notify(); });
+  try {
+    for (;;) {
+      const item = queue.shift();
+      if (item !== undefined) { yield item; continue; }
+      if (ended) return;
+      await new Promise<void>(resolve => { waiting = resolve; });
+    }
+  } finally {
+    detach();
+  }
 }
 
 export function createCollectorsResources(client: Client): CollectorsResources {
@@ -85,5 +124,49 @@ export function createCollectorsResources(client: Client): CollectorsResources {
         if (signal?.aborted) abort();
       });
     },
+    collectMessages(channelID: string, input: CollectMessagesInput): AsyncIterable<CollectedMessageInfo> {
+      const time = positiveBound(input.timeMs);
+      const max = positiveBound(input.max);
+      requireBounds(time, max, input.signal);
+      const filter = input.userID === undefined && input.contains === undefined
+        ? undefined
+        : (message: Message) =>
+          (input.userID === undefined || message.author.id === input.userID) &&
+          (input.contains === undefined || message.content.includes(input.contains));
+      const signal = input.signal;
+      return pump<CollectedMessageInfo>((push, finish) => {
+        // O SDK exige time ou max; com só signal o teto de max é inalcançável e o abort encerra.
+        const collector = new MessageCollector(client, channelID, {
+          filter, time, max: time > 0 || max > 0 ? max : Number.MAX_SAFE_INTEGER,
+        });
+        const abort = (): void => collector.stop('user');
+        collector.on('collect', message => push(info(message)));
+        collector.on('end', () => finish());
+        signal?.addEventListener('abort', abort, { once: true });
+        if (signal?.aborted) collector.stop('user');
+        return () => { signal?.removeEventListener('abort', abort); collector.stop('user'); };
+      });
+    },
+    collectReactions(channelID: string, input: CollectReactionsInput): AsyncIterable<ReactionVote> {
+      const time = positiveBound(input.timeMs);
+      const max = positiveBound(input.max);
+      requireBounds(time, max, input.signal);
+      if (!input.messageID) throw new YuzuhaError('COLLECTOR_MESSAGE', 'Informe a mensagem (messageID) para coletar reações.');
+      const wanted = targets(input.emojis ?? []);
+      const signal = input.signal;
+      return pump<ReactionVote>((push, finish) => {
+        const collector = new ReactionCollector(client, input.messageID, channelID, {
+          time, max,
+          filter: (reaction, user) => (input.userID === undefined || user.id === input.userID)
+            && (wanted.length === 0 || matches(reaction, wanted)),
+        });
+        const abort = (): void => collector.stop('user');
+        collector.on('collect', (reaction, user) => push(voteInfo(reaction, user.id)));
+        collector.on('end', () => finish());
+        signal?.addEventListener('abort', abort, { once: true });
+        if (signal?.aborted) collector.stop('user');
+        return () => { signal?.removeEventListener('abort', abort); collector.stop('user'); };
+      });
+    },
   };
 }

package/src/infrastructure/fluxer/resources/expressions.ts

@@ -1,6 +1,6 @@
 import type { Client, GuildEmoji, GuildSticker } from '@fluxerjs/core';
 import { YuzuhaError } from '../../../errors.js';
-import { emojiBatch } from '../../../domain/resource-batches.js';
+import { emojiBatch, stickerBatch } from '../../../domain/resource-batches.js';
 import type { EmojiInfo, ExpressionsResources, StickerInfo } from '../../../ports/resources/expressions.js';
 
 function toEmojiInfo(emoji: GuildEmoji): EmojiInfo {
@@ -68,6 +68,12 @@ export function createExpressionsResources(client: Client): ExpressionsResources
       toEmojiInfo(await (await resolveEmoji(guildID, nameOrID)).edit({ name, reason })),
     createSticker: async (guildID, input) =>
       toStickerInfo(await (await guild(guildID)).createSticker(input)),
+    createStickersBulk: async (guildID, inputs) => {
+      const batch = stickerBatch(inputs);
+      if (!guildID) throw new YuzuhaError('GUILD_REQUIRED', 'Esta operação exige um servidor.');
+      const result = await (await guild(guildID)).createStickersBulk(batch);
+      return { success: result.success.map(toStickerInfo), failed: result.failed.map(item => ({ name: item.name, error: item.error })) };
+    },
     editSticker: async (guildID, nameOrID, input) =>
       toStickerInfo(await (await resolveSticker(guildID, nameOrID)).edit(input)),
     deleteSticker: async (guildID, nameOrID, reason) => {

package/src/infrastructure/fluxer/resources/gateway.ts

@@ -0,0 +1,33 @@
+import type { Client } from '@fluxerjs/core';
+import type { GatewayResources } from '../../../ports/resources/gateway.js';
+
+export function createGatewayResources(client: Client): GatewayResources {
+  return {
+    requestMembers(input) {
+      client.requestGuildMembers({
+        guildId: input.guildID, guildIds: input.guildIDs, query: input.query, limit: input.limit,
+        userIds: input.userIDs, presences: input.presences, nonce: input.nonce,
+      });
+    },
+    requestGuildCounts(guildIDs, nonce) {
+      client.requestGuildCounts({ guildIds: guildIDs, nonce });
+    },
+    requestChannelCounts(input) {
+      client.requestChannelMemberCounts({
+        guildId: input.guildID, channelId: input.channelID, channelIds: input.channelIDs, nonce: input.nonce,
+      });
+    },
+    requestForumUnreads(input) {
+      client.requestForumUnreads({
+        guildId: input.guildID, channelId: input.channelID,
+        threads: input.threads.map(thread => ({ threadId: thread.threadID, ackMessageId: thread.ackMessageID })),
+      });
+    },
+    subscribeThreads(input) {
+      client.subscribeThreads({ guildId: input.guildID, threads: input.threads, threadIds: input.threadIDs });
+    },
+    send(shardID, payload) {
+      client.sendToGateway(shardID, payload);
+    },
+  };
+}

package/src/infrastructure/fluxer/resources/instance.ts

@@ -0,0 +1,105 @@
+import type { Client } from '@fluxerjs/core';
+import type { APIApplicationMe, APIInstance, APIInstanceEndpoints, APIOAuthApplication } from '@fluxerjs/types';
+import type {
+  ApplicationInfo,
+  InstanceInfo,
+  InstanceResources,
+} from '../../../ports/resources/instance.js';
+
+function instanceInfo(endpoints: APIInstanceEndpoints, discovery: APIInstance | null): InstanceInfo {
+  return {
+    apiCodeVersion: discovery?.api_code_version ?? null,
+    codename: discovery?.codename ?? null,
+    endpoints: {
+      api: endpoints.api,
+      apiClient: endpoints.api_client,
+      apiPublic: endpoints.api_public,
+      gateway: endpoints.gateway,
+      media: endpoints.media,
+      staticCDN: endpoints.static_cdn,
+      marketing: endpoints.marketing,
+      admin: endpoints.admin,
+      invite: endpoints.invite,
+      gift: endpoints.gift,
+      webapp: endpoints.webapp,
+    },
+    features: discovery?.features ? {
+      voiceEnabled: discovery.features.voice_enabled,
+      stripeEnabled: discovery.features.stripe_enabled,
+      selfHosted: discovery.features.self_hosted,
+      presignedAttachmentUploads: discovery.features.presigned_attachment_uploads,
+      emailsEnabled: discovery.features.emails_enabled,
+    } : null,
+    registrationMode: discovery?.registration?.mode ?? null,
+    ssoEnabled: discovery?.sso?.enabled ?? null,
+    ssoEnforced: discovery?.sso?.enforced ?? null,
+    singleCommunity: discovery?.community?.single_community ?? null,
+    singleCommunityGuildID: discovery?.community?.single_community_guild_id ?? null,
+    directMessagesDisabled: discovery?.community?.direct_messages_disabled ?? null,
+    services: discovery?.services ? {
+      gif: discovery.services.gif_enabled,
+      youtube: discovery.services.youtube_enabled,
+      bluesky: discovery.services.bluesky_enabled,
+    } : null,
+  };
+}
+
+function applicationInfo(application: APIApplicationMe | APIOAuthApplication): ApplicationInfo {
+  return {
+    id: application.id,
+    name: application.name,
+    icon: application.icon ?? null,
+    description: application.description ?? null,
+    botPublic: application.bot_public ?? null,
+    botRequireCodeGrant: application.bot_require_code_grant ?? null,
+    verifyKey: 'verify_key' in application ? application.verify_key ?? null : null,
+    flags: 'flags' in application ? application.flags ?? null : null,
+    ownerID: 'owner' in application ? application.owner?.id ?? null : null,
+    botID: 'bot' in application ? application.bot?.id ?? null : null,
+    redirectURIs: 'redirect_uris' in application ? [...application.redirect_uris ?? []] : [],
+    clientSecret: 'client_secret' in application ? application.client_secret ?? null : null,
+  };
+}
+
+export function createInstanceResources(client: Client): InstanceResources {
+  return {
+    async describe() {
+      const resolved = client.instance;
+      const fetched = await client.fetchInstance();
+      return instanceInfo(fetched?.endpoints ?? resolved.endpoints, fetched ?? resolved.discovery);
+    },
+    async gatewayInfo() {
+      const info = await client.fetchGatewayInfo();
+      const limit = info.session_start_limit;
+      return {
+        url: info.url,
+        shards: info.shards,
+        sessionStartLimit: limit ? {
+          total: limit.total,
+          remaining: limit.remaining,
+          resetAfter: limit.reset_after,
+          maxConcurrency: limit.max_concurrency,
+        } : null,
+      };
+    },
+    async application() {
+      return applicationInfo(await client.fetchApplication());
+    },
+    async oauthApplications() {
+      return (await client.fetchOAuthApplications()).map(applicationInfo);
+    },
+    async emojiMetadata(emojiID) {
+      const metadata = await client.fetchEmojiMetadata(emojiID);
+      return { id: metadata.id, guildID: metadata.guild_id, name: metadata.name,
+        animated: metadata.animated, allowCloning: metadata.allow_cloning };
+    },
+    async stickerMetadata(stickerID) {
+      const metadata = await client.fetchStickerMetadata(stickerID);
+      return { id: metadata.id, guildID: metadata.guild_id, name: metadata.name,
+        animated: metadata.animated, allowCloning: metadata.allow_cloning };
+    },
+    resolveEmoji(emoji, guildID) {
+      return client.resolveEmoji(emoji, guildID);
+    },
+  };
+}

package/src/infrastructure/fluxer/resources/messages.ts

@@ -4,7 +4,7 @@ import type { ReceivedEmbed, ReceivedEmbedMedia } from '../../../domain/messages
 import { limitOf } from '../../../ports/resources/common.js';
 import type { AttachmentSpec, BinaryAttachmentSpec } from '../../../ports/resources/common.js';
 import { YuzuhaError } from '../../../errors.js';
-import type { MessageInfo, MessagesResources } from '../../../ports/resources/messages.js';
+import type { BulkFetchRawChannel, MessageInfo, MessageSearchInput, MessageSearchPage, MessagesResources } from '../../../ports/resources/messages.js';
 import { preloadChannels } from '../../../domain/resource-batches.js';
 import { messageSearchInput, pinnedMessagesInput, reactionUsersInput } from '../../../domain/message-query.js';
 
@@ -27,7 +27,7 @@ function receivedEmbed(embed: MessageEmbed): ReceivedEmbed {
   };
 }
 
-function info(message: Message): MessageInfo {
+export function toMessageInfo(message: Message): MessageInfo {
   return {
     id: message.id, channelID: message.channelId, authorID: message.author.id,
     authorName: message.author.username, content: message.content,
@@ -51,22 +51,53 @@ export function createMessagesResources(client: Client): MessagesResources {
     }
     const builders = files.map(file => {
       if (!file.name.trim() || file.name.length > 255) throw new YuzuhaError('ATTACHMENT_NAME', 'Nome de anexo deve ter de 1 a 255 caracteres.');
-      return new AttachmentBuilder('data' in file ? Buffer.from(file.data) : file.url,
+      const builder = new AttachmentBuilder('data' in file ? Buffer.from(file.data) : file.url,
         { name: file.name, description: file.description });
+      if (file.spoiler) builder.setSpoiler();
+      return builder;
     });
     return (await client.channels.send(channelID, { content, files: builders,
       attachments: builders.map((builder, id) => builder.toJSON(id)),
       allowedMentions: { parse: [], repliedUser: false },
     })).id;
   };
+  const search = async (rawInput: MessageSearchInput): Promise<MessageSearchPage> => {
+    const input = messageSearchInput(rawInput);
+    const result = await client.searchMessages({ content: input.content,
+      contextGuildId: input.guildID, contextChannelId: input.channelID,
+      channelIds: input.channelIDs ?? (input.channelID ? [input.channelID] : undefined),
+      authorIds: input.authorIDs ?? (input.authorID ? [input.authorID] : undefined),
+      hitsPerPage: limitOf(input.limit, 25, 100), cursor: input.cursor,
+      ...(input.contents === undefined ? {} : { contents: input.contents }),
+      ...(input.exactPhrases === undefined ? {} : { exactPhrases: input.exactPhrases }),
+      ...(input.excludeChannelIDs === undefined ? {} : { excludeChannelIds: input.excludeChannelIDs }),
+      ...(input.excludeAuthorIDs === undefined ? {} : { excludeAuthorIds: input.excludeAuthorIDs }),
+      ...(input.authorType === undefined ? {} : { authorType: input.authorType }),
+      ...(input.excludeAuthorType === undefined ? {} : { excludeAuthorType: input.excludeAuthorType }),
+      ...(input.mentions === undefined ? {} : { mentions: input.mentions }),
+      ...(input.excludeMentions === undefined ? {} : { excludeMentions: input.excludeMentions }),
+      ...(input.mentionEveryone === undefined ? {} : { mentionEveryone: input.mentionEveryone }),
+      ...(input.pinned === undefined ? {} : { pinned: input.pinned }),
+      ...(input.includeNsfw === undefined ? {} : { includeNsfw: input.includeNsfw }),
+      ...(input.has === undefined ? {} : { has: input.has }),
+      ...(input.excludeHas === undefined ? {} : { excludeHas: input.excludeHas }),
+      ...(input.minID === undefined ? {} : { minId: input.minID }),
+      ...(input.maxID === undefined ? {} : { maxId: input.maxID }),
+      ...(input.sortBy === undefined ? {} : { sortBy: input.sortBy }),
+      ...(input.sortOrder === undefined ? {} : { sortOrder: input.sortOrder }),
+      ...(input.page === undefined ? {} : { page: input.page }) });
+    if ('indexing' in result) return { indexing: true, messages: [], total: 0, cursor: null };
+    return { indexing: false, messages: result.messages.map(data => toMessageInfo(new Message(client, data))),
+      total: result.total, cursor: result.cursor ?? null };
+  };
   return {
     async preload(channelIDs) {
       const ids = preloadChannels(channelIDs);
       const result = await client.preloadMessages(ids);
-      return Object.fromEntries(ids.map(id => [id, result[id] ? info(new Message(client, result[id])) : null]));
+      return Object.fromEntries(ids.map(id => [id, result[id] ? toMessageInfo(new Message(client, result[id])) : null]));
     },
     async fetch(channelID: string, messageID: string): Promise<MessageInfo> {
-      return info(await client.channels.fetchMessage(channelID, messageID));
+      return toMessageInfo(await client.channels.fetchMessage(channelID, messageID));
     },
     async list(channelID, limit, cursor = {}): Promise<MessageInfo[]> {
       if (Object.values(cursor).filter(value => value !== undefined).length > 1) {
@@ -75,7 +106,7 @@ export function createMessagesResources(client: Client): MessagesResources {
       const channel = await client.channels.fetch(channelID, { force: true });
       if (!channel.isTextBased()) throw new YuzuhaError('CHANNEL_TEXT', 'Canal sem suporte a mensagens.');
       const messages = await channel.messages.fetch({ limit: limitOf(limit, 20, 100), ...cursor });
-      return order([...messages.values()].map(info));
+      return order([...messages.values()].map(toMessageInfo));
     },
     async pin(channelID: string, messageID: string): Promise<void> {
       await (await client.channels.fetchMessage(channelID, messageID)).pin();
@@ -90,14 +121,14 @@ export function createMessagesResources(client: Client): MessagesResources {
       const messages = limit === undefined
         ? await channel.fetchPinnedMessages()
         : await channel.fetchPinnedMessagesPage({ limit }).then(page => page.messages);
-      return order(messages.map(info));
+      return order(messages.map(toMessageInfo));
     },
     async pinnedPage(channelID, input) {
       const options = pinnedMessagesInput(input);
       const channel = await client.channels.fetch(channelID, { force: true });
       if (!channel.isTextBased()) throw new YuzuhaError('CHANNEL_TEXT', 'Canal sem suporte a mensagens.');
       const page = await channel.fetchPinnedMessagesPage(options);
-      return { messages: page.messages.map(info), pinnedAt: [...page.pinnedAt], hasMore: page.hasMore,
+      return { messages: page.messages.map(toMessageInfo), pinnedAt: [...page.pinnedAt], hasMore: page.hasMore,
         nextBefore: page.hasMore ? page.pinnedAt.at(-1) ?? null : null };
     },
     sendFiles: send,
@@ -111,34 +142,19 @@ export function createMessagesResources(client: Client): MessagesResources {
         allowedMentions: { parse: [], repliedUser: false },
       })).id;
     },
-    async search(rawInput) {
-      const input = messageSearchInput(rawInput);
-      const result = await client.searchMessages({ content: input.content,
-        contextGuildId: input.guildID, contextChannelId: input.channelID,
-        channelIds: input.channelIDs ?? (input.channelID ? [input.channelID] : undefined),
-        authorIds: input.authorIDs ?? (input.authorID ? [input.authorID] : undefined),
-        hitsPerPage: limitOf(input.limit, 25, 100), cursor: input.cursor,
-        ...(input.contents === undefined ? {} : { contents: input.contents }),
-        ...(input.exactPhrases === undefined ? {} : { exactPhrases: input.exactPhrases }),
-        ...(input.excludeChannelIDs === undefined ? {} : { excludeChannelIds: input.excludeChannelIDs }),
-        ...(input.excludeAuthorIDs === undefined ? {} : { excludeAuthorIds: input.excludeAuthorIDs }),
-        ...(input.authorType === undefined ? {} : { authorType: input.authorType }),
-        ...(input.excludeAuthorType === undefined ? {} : { excludeAuthorType: input.excludeAuthorType }),
-        ...(input.mentions === undefined ? {} : { mentions: input.mentions }),
-        ...(input.excludeMentions === undefined ? {} : { excludeMentions: input.excludeMentions }),
-        ...(input.mentionEveryone === undefined ? {} : { mentionEveryone: input.mentionEveryone }),
-        ...(input.pinned === undefined ? {} : { pinned: input.pinned }),
-        ...(input.includeNsfw === undefined ? {} : { includeNsfw: input.includeNsfw }),
-        ...(input.has === undefined ? {} : { has: input.has }),
-        ...(input.excludeHas === undefined ? {} : { excludeHas: input.excludeHas }),
-        ...(input.minID === undefined ? {} : { minId: input.minID }),
-        ...(input.maxID === undefined ? {} : { maxId: input.maxID }),
-        ...(input.sortBy === undefined ? {} : { sortBy: input.sortBy }),
-        ...(input.sortOrder === undefined ? {} : { sortOrder: input.sortOrder }),
-        ...(input.page === undefined ? {} : { page: input.page }) });
-      if ('indexing' in result) return { indexing: true, messages: [], total: 0, cursor: null };
-      return { indexing: false, messages: result.messages.map(data => info(new Message(client, data))),
-        total: result.total, cursor: result.cursor ?? null };
+    search,
+    searchAll: search,
+    async bulkFetch(requests, input): Promise<MessageInfo[] | BulkFetchRawChannel[]> {
+      const options = requests.map(request => ({ channelId: request.channelID, limit: request.limit,
+        ...(request.before === undefined ? {} : { before: request.before }),
+        ...(request.after === undefined ? {} : { after: request.after }),
+        ...(request.around === undefined ? {} : { around: request.around }) }));
+      if (input?.hydrate === false) {
+        const raw = await client.bulkFetchMessages(options, { hydrate: false });
+        return raw.channels.map(channel => ({ channelID: channel.channel_id, messages: channel.messages }));
+      }
+      const result = await client.bulkFetchMessages(options);
+      return result.channels.flatMap(channel => [...channel.messages.values()].map(toMessageInfo));
     },
     sendBytes: send,
     sendAttachments: send,
@@ -164,5 +180,37 @@ export function createMessagesResources(client: Client): MessagesResources {
       const page = await message.fetchReactionUsersPage(emoji, input);
       return { users: page.users.map(user => user.id), hasMore: page.hasMore, nextAfter: page.nextAfter };
     },
+    async deleteAttachment(channelID, messageID, attachmentID): Promise<void> {
+      await (await client.channels.fetchMessage(channelID, messageID)).deleteAttachment(attachmentID);
+    },
+    async sendTo(channelID, content): Promise<string> {
+      return (await client.channels.send(channelID, { content, allowedMentions: { parse: [], repliedUser: false } })).id;
+    },
+    async bulkDelete(channelID, messageIDs): Promise<string[]> {
+      const channel = await client.channels.fetch(channelID, { force: true });
+      if (!channel.isTextBased()) throw new YuzuhaError('CHANNEL_TEXT', 'Canal sem suporte a mensagens.');
+      return channel.bulkDelete(messageIDs);
+    },
+    async bulkDeleteOwn(channelID): Promise<void> {
+      const channel = await client.channels.fetch(channelID, { force: true });
+      if (!channel.isTextBased()) throw new YuzuhaError('CHANNEL_TEXT', 'Canal sem suporte a mensagens.');
+      await channel.bulkDeleteMyMessages();
+    },
+    async acknowledgePins(channelID): Promise<void> {
+      const channel = await client.channels.fetch(channelID, { force: true });
+      if (!channel.isTextBased()) throw new YuzuhaError('CHANNEL_TEXT', 'Canal sem suporte a mensagens.');
+      await channel.acknowledgePins();
+    },
+    async clearReadState(channelID): Promise<void> {
+      const channel = await client.channels.fetch(channelID, { force: true });
+      if (!channel.isTextBased()) throw new YuzuhaError('CHANNEL_TEXT', 'Canal sem suporte a mensagens.');
+      await channel.clearReadState();
+    },
+    async purgeDM(channelID): Promise<number> {
+      const channel = await client.channels.fetch(channelID, { force: true });
+      if (!channel.isDM()) throw new YuzuhaError('CHANNEL_DM', 'Esta operação exige um canal de DM.');
+      if (Number(channel.type) !== 999) throw new YuzuhaError('CHANNEL_NOTES', 'purgeDM só funciona no canal de anotações pessoais.');
+      return channel.purgeMessages();
+    },
   };
 }

package/src/infrastructure/fluxer/resources/roles.ts

@@ -10,6 +10,7 @@ function toInfo(role: Role): RoleInfo {
     position: role.position,
     permissions: role.permissions.bitfield.toString(),
     hoist: role.hoist,
+    hoistPosition: role.hoistPosition,
     mentionable: role.mentionable,
     unicodeEmoji: role.unicodeEmoji,
     managed: Reflect.get(role, 'managed') === true,
@@ -103,6 +104,13 @@ export function createRolesResources(client: Client): RolesResources {
       const guild = await getGuild(client, guildID);
       await (await resolveRole(guild, role)).delete(reason);
     },
+    async setRoleHoistPositions(guildID, updates) {
+      const guild = await client.guilds.resolve(guildID);
+      return (await guild.setRoleHoistPositions(updates)).map(toInfo);
+    },
+    async resetRoleHoistPositions(guildID) {
+      return (await (await client.guilds.resolve(guildID)).resetRoleHoistPositions()).map(toInfo);
+    },
     async move(guildID, role, position): Promise<void> {
       if (!Number.isSafeInteger(position) || position < 0) throw new YuzuhaError('POSITION', 'Posição deve ser um inteiro a partir de 0.');
       const guild = await getGuild(client, guildID);

package/src/infrastructure/fluxer/resources/self.ts

@@ -0,0 +1,39 @@
+import type { Client, ClientUser } from '@fluxerjs/core';
+import { YuzuhaError } from '../../../errors.js';
+import type { SelfResources } from '../../../ports/resources/self.js';
+import { toUserInfo } from './users.js';
+
+function selfUser(client: Client): ClientUser {
+  const user = client.user;
+  if (!user) {
+    throw new YuzuhaError('NOT_READY', 'O cliente ainda não está pronto; o usuário autenticado não está disponível.');
+  }
+  return user;
+}
+
+export function createSelfResources(client: Client): SelfResources {
+  return {
+    async fetch() {
+      return toUserInfo(await selfUser(client).fetch());
+    },
+    async guilds(input) {
+      const guilds = await selfUser(client).fetchGuilds({ withCounts: input?.withCounts ?? false });
+      return guilds.map(guild => ({
+        id: guild.id,
+        name: guild.name,
+        icon: guild.icon,
+        owner: guild.owner ?? false,
+        permissions: guild.permissions ?? null,
+        features: guild.features ?? [],
+        memberCount: guild.approximateMemberCount ?? null,
+        onlineCount: guild.approximatePresenceCount ?? null,
+      }));
+    },
+    async leaveGuild(guildID, verification) {
+      await selfUser(client).leaveGuild(guildID, verification);
+    },
+    async deleteMyMessages(guildID, verification) {
+      await selfUser(client).bulkDeleteMyMessagesInGuild(guildID, verification);
+    },
+  };
+}

package/src/infrastructure/fluxer/resources/threads.ts

@@ -133,6 +133,20 @@ export function createThreadsResources(client: Client): ThreadsResources {
     },
     async join(threadID) { await asThread(await client.channels.fetch(threadID)).join(); },
     async leave(threadID) { await asThread(await client.channels.fetch(threadID)).leave(); },
+    async setLocked(threadID, locked, reason): Promise<void> {
+      await asThread(await client.channels.fetch(threadID)).setLocked(locked, reason);
+    },
+    async editSelf(threadID, input) {
+      const member = await asThread(await client.channels.fetch(threadID)).editSelf(input);
+      return member === null ? null : { threadID: member.id, userID: member.userId,
+        joinedTimestamp: member.joinedAt.getTime(), flags: member.flags };
+    },
+    async editDefaults(parentID, input): Promise<void> {
+      const { slowmode, autoArchiveDuration, reason } = input;
+      await parentThreads(await client.channels.fetch(parentID)).editDefaults({
+        autoArchiveDuration: autoArchiveDuration === null ? null : archiveDuration(autoArchiveDuration),
+        rateLimitPerUser: slowmode, reason });
+    },
     async search(channelID, input) {
       const limit = input.limit ?? 25, offset = input.offset ?? 0;
       if (!Number.isSafeInteger(limit) || limit < 1 || limit > 25 || !Number.isSafeInteger(offset) || offset < 0 || offset > 9975) {

package/src/infrastructure/fluxer/resources/users.ts

@@ -1,4 +1,4 @@
-import type { Client, Guild, GuildMember, PresenceUpdateOptions, User, ProfilePayload } from '@fluxerjs/core';
+import type { Client, DiscoveryApplicationPayload, Guild, GuildMember, PresenceUpdateOptions, User, ProfilePayload } from '@fluxerjs/core';
 import type { ActivityInfo, ActivityType, PresenceStatus } from '../../../ports/resources/common.js';
 import { limitOf } from '../../../ports/resources/common.js';
 import type {
@@ -11,6 +11,8 @@ import type {
   LiveCountsInput,
   ProfileInfo,
 } from '../../../ports/resources/users.js';
+import type { DiscoveryApplicationInfo } from '../../../ports/resources/users.js';
+import type { ChannelInfo } from '../../../ports/resources/channels.js';
 import { YuzuhaError } from '../../../errors.js';
 
 /** Época Fluxer (01/01/2015 UTC) para derivar timestamps de snowflakes. */
@@ -65,7 +67,7 @@ function snowflakeTimestamp(id: string): number {
   return Number((BigInt(id) >> 22n) + FLUXER_EPOCH);
 }
 
-function toUserInfo(user: User): UserInfo {
+export function toUserInfo(user: User): UserInfo {
   return {
     id: user.id,
     username: user.username,
@@ -77,7 +79,7 @@ function toUserInfo(user: User): UserInfo {
   };
 }
 
-function toMemberInfo(member: GuildMember): MemberInfo {
+export function toMemberInfo(member: GuildMember): MemberInfo {
   const user = member.user;
   return {
     id: member.id,
@@ -95,7 +97,7 @@ function toMemberInfo(member: GuildMember): MemberInfo {
   };
 }
 
-function toGuildInfo(guild: Guild): GuildInfo {
+export function toGuildInfo(guild: Guild): GuildInfo {
   return {
     id: guild.id,
     name: guild.name,
@@ -108,6 +110,13 @@ function toGuildInfo(guild: Guild): GuildInfo {
   };
 }
 
+function toDiscoveryApplicationInfo(payload: DiscoveryApplicationPayload): DiscoveryApplicationInfo {
+  return { guildID: payload.guildId, status: payload.status, description: payload.description,
+    categoryType: payload.categoryType, primaryLanguage: payload.primaryLanguage ?? null,
+    customTags: payload.customTags, appliedAt: payload.appliedAt, reviewedAt: payload.reviewedAt ?? null,
+    guildNsfwLevel: payload.guildNsfwLevel ?? null };
+}
+
 export function createUsersResources(client: Client): UsersResources {
   return {
     async leaveGuild(guildID) {
@@ -186,6 +195,27 @@ export function createUsersResources(client: Client): UsersResources {
       const { systemChannelID, afkChannelID, ...fields } = input;
       return toGuildInfo(await guild.edit({ ...fields, systemChannelId: systemChannelID, afkChannelId: afkChannelID }));
     },
+    async me(guildID) {
+      const guild = await client.guilds.resolve(guildID);
+      return toMemberInfo(await guild.members.fetchMe());
+    },
+    async transferOwnership(guildID, userID): Promise<void> {
+      await (await client.guilds.resolve(guildID)).transferOwnership(userID);
+    },
+    async withdrawDiscoveryApplication(guildID): Promise<void> {
+      await (await client.guilds.resolve(guildID)).withdrawDiscoveryApplication();
+    },
+    async discoveryStatus(guildID) {
+      const status = await (await client.guilds.resolve(guildID)).fetchDiscoveryStatus();
+      return { application: status.application ? toDiscoveryApplicationInfo(status.application) : null,
+        eligible: status.eligible, minMemberCount: status.minMemberCount };
+    },
+    async applyForDiscovery(guildID, input) {
+      return toDiscoveryApplicationInfo(await (await client.guilds.resolve(guildID)).applyForDiscovery(input));
+    },
+    async editDiscoveryApplication(guildID, input) {
+      return toDiscoveryApplicationInfo(await (await client.guilds.resolve(guildID)).editDiscoveryApplication(input));
+    },
     async setPresence(status: PresenceStatus, activity?: ActivityInfo): Promise<void> {
       const self = client.user;
       if (!self) throw new YuzuhaError('NOT_READY', 'O cliente ainda não está pronto para definir presença.');
@@ -204,5 +234,11 @@ export function createUsersResources(client: Client): UsersResources {
       }
       self.setPresence(presence);
     },
+    async createDM(userID): Promise<ChannelInfo> {
+      const user = await client.users.fetch(userID, { force: true });
+      const dm = await user.createDM();
+      return { id: dm.id, name: '', type: 1, guildID: null, parentID: null, position: 0,
+        topic: null, slowmode: 0, nsfw: false };
+    },
   };
 }

package/src/infrastructure/fluxer/resources/webhooks.ts

@@ -40,5 +40,14 @@ export function createWebhooksResources(client: Client): WebhooksResources {
       const webhook = token ? Webhook.fromToken(client, webhookID, token) : await Webhook.fetch(client, webhookID);
       await webhook.delete();
     },
+    editMessage: async (webhookID, token, messageID, input) => {
+      const webhook = Webhook.fromToken(client, webhookID, token);
+      const message = await webhook.editMessage(messageID, { content: input.content });
+      return message.id;
+    },
+    deleteMessage: async (webhookID, token, messageID) => {
+      const webhook = Webhook.fromToken(client, webhookID, token);
+      await webhook.deleteMessage(messageID);
+    },
   };
 }