@discord-selfbot/core 14.0.1 → 14.0.2

package/src/structures/Channel.ts

@@ -1,6 +1,3 @@
-import { createRequire } from 'node:module';
-
-const require = createRequire(import.meta.url);
 import process from 'node:process';
 import Base from './Base';
 import type { Client } from '../client/Client';
@@ -8,64 +5,14 @@ import type { Guild } from './Guild';
 import type { RawChannelData } from '../../typings/rawDataTypes';
 import ChannelFlags from '../util/ChannelFlags';
 import _ConstantsModule from '../util/Constants';
-
-const { ChannelTypes, ThreadChannelTypes, VoiceBasedChannelTypes } =
-  _ConstantsModule;
 import SnowflakeUtil from '../util/SnowflakeUtil';
 import type { ChannelEntity } from '../types/entities/channel';
 import type { PatchOf } from '../types/schema';
 import type ClientType from '../client/Client';
-import type ThreadChannelType from './ThreadChannel';
-import type { Snowflake } from 'discord-api-types/v10';
-import { isThreadParentChannel } from '../types/channels';
+import { constructChannel } from './ChannelConstruction';
 
-let CategoryChannel: new (
-  guild: Guild,
-  data: RawChannelData,
-  client: Client
-) => Channel;
-let DMChannel: new (client: Client, data: RawChannelData) => Channel;
-let NewsChannel: new (
-  guild: Guild,
-  data: RawChannelData,
-  client: Client
-) => Channel;
-let StageChannel: new (
-  guild: Guild,
-  data: RawChannelData,
-  client: Client
-) => Channel;
-let StoreChannel: new (
-  guild: Guild,
-  data: RawChannelData,
-  client: Client
-) => Channel;
-let TextChannel: new (
-  guild: Guild,
-  data: RawChannelData,
-  client: Client
-) => Channel;
-let ThreadChannel: new (
-  guild: Guild,
-  data: RawChannelData,
-  client: Client
-) => ThreadChannelType;
-let VoiceChannel: new (
-  guild: Guild,
-  data: RawChannelData,
-  client: Client
-) => Channel;
-let DirectoryChannel: new (client: Client, data: RawChannelData) => Channel;
-let ForumChannel: new (
-  guild: Guild,
-  data: RawChannelData,
-  client: Client
-) => Channel;
-let MediaChannel: new (
-  guild: Guild,
-  data: RawChannelData,
-  client: Client
-) => Channel;
+const { ChannelTypes, ThreadChannelTypes, VoiceBasedChannelTypes } =
+  _ConstantsModule;
 
 /**
  * @type {WeakSet<Channel>}
@@ -75,116 +22,6 @@ let MediaChannel: new (
 const deletedChannels = new WeakSet();
 let deprecationEmittedForDeleted = false;
 
-function loadChannelClasses() {
-  CategoryChannel ??= require('./CategoryChannel').default;
-  DMChannel ??= require('./DMChannel').default;
-  NewsChannel ??= require('./NewsChannel').default;
-  StageChannel ??= require('./StageChannel').default;
-  StoreChannel ??= require('./StoreChannel').default;
-  TextChannel ??= require('./TextChannel').default;
-  ThreadChannel ??= require('./ThreadChannel').default;
-  VoiceChannel ??= require('./VoiceChannel').default;
-  DirectoryChannel ??= require('./DirectoryChannel').default;
-  ForumChannel ??= require('./ForumChannel').default;
-  MediaChannel ??= require('./MediaChannel').default;
-}
-
-function cacheGuildChannel(cache: Map<Snowflake, unknown>, channel: Channel) {
-  cache.set(channel.id, channel);
-}
-
-function requireGuild(guild: Guild | null | undefined): Guild {
-  if (!guild) {
-    throw new TypeError('A guild is required to create a guild channel');
-  }
-  return guild;
-}
-
-function createDirectMessageChannel(client: Client, data: RawChannelData) {
-  let channel;
-  if (
-    ('recipients' in data &&
-      data.recipients &&
-      data.type !== ChannelTypes.GROUP_DM) ||
-    data.type === ChannelTypes.DM
-  ) {
-    channel = new DMChannel(client, data);
-  } else if (data.type === ChannelTypes.GROUP_DM) {
-    const GroupDMChannel = require('./GroupDMChannel').default;
-    channel = new GroupDMChannel(client, data);
-  }
-  return channel;
-}
-
-function createGuildChannel(
-  client: Client,
-  data: RawChannelData,
-  guild: Guild | undefined,
-  allowUnknownGuild: boolean
-) {
-  let channel;
-  switch (data.type) {
-    case ChannelTypes.GUILD_TEXT: {
-      channel = new TextChannel(requireGuild(guild), data, client);
-      break;
-    }
-    case ChannelTypes.GUILD_VOICE: {
-      channel = new VoiceChannel(requireGuild(guild), data, client);
-      break;
-    }
-    case ChannelTypes.GUILD_CATEGORY: {
-      channel = new CategoryChannel(requireGuild(guild), data, client);
-      break;
-    }
-    case ChannelTypes.GUILD_NEWS: {
-      channel = new NewsChannel(requireGuild(guild), data, client);
-      break;
-    }
-    case ChannelTypes.GUILD_STORE: {
-      channel = new StoreChannel(requireGuild(guild), data, client);
-      break;
-    }
-    case ChannelTypes.GUILD_STAGE_VOICE: {
-      channel = new StageChannel(requireGuild(guild), data, client);
-      break;
-    }
-    case ChannelTypes.GUILD_NEWS_THREAD:
-    case ChannelTypes.GUILD_PUBLIC_THREAD:
-    case ChannelTypes.GUILD_PRIVATE_THREAD: {
-      const thread = new ThreadChannel(requireGuild(guild), data, client);
-      if (
-        !allowUnknownGuild &&
-        thread.parent &&
-        isThreadParentChannel(thread.parent)
-      ) {
-        thread.parent.threads.cache.set(thread.id, thread);
-      }
-      channel = thread;
-      break;
-    }
-
-    case ChannelTypes.GUILD_DIRECTORY: {
-      channel = new DirectoryChannel(client, data);
-      break;
-    }
-
-    case ChannelTypes.GUILD_FORUM: {
-      channel = new ForumChannel(requireGuild(guild), data, client);
-      break;
-    }
-
-    case ChannelTypes.GUILD_MEDIA: {
-      channel = new MediaChannel(requireGuild(guild), data, client);
-      break;
-    }
-
-    default: {
-      break;
-    }
-  }
-  return channel;
-}
-
 class Channel extends Base implements ChannelEntity {
   declare id: ChannelEntity['id'];
   declare type: ChannelEntity['type'];
@@ -295,33 +132,35 @@ class Channel extends Base implements ChannelEntity {
     return this.type === 'GUILD_DIRECTORY';
   }
 
-  static create(
+  static construct(
     client: Client,
     data: RawChannelData,
     guild?: Guild | null,
     { allowUnknownGuild = false }: { allowUnknownGuild?: boolean } = {}
   ) {
-    loadChannelClasses();
-
-    let channel;
-    const guildId = 'guild_id' in data ? data.guild_id : undefined;
-    if (!guildId && !guild) {
-      channel = createDirectMessageChannel(client, data);
-    } else {
-      const resolvedGuild =
-        guild ?? (guildId ? client.guilds.cache.get(guildId) : undefined);
+    return constructChannel(client, data, guild, { allowUnknownGuild });
+  }
 
-      if (resolvedGuild || allowUnknownGuild) {
-        channel = createGuildChannel(
-          client,
-          data,
-          resolvedGuild,
-          allowUnknownGuild
-        );
-        if (channel && !allowUnknownGuild && resolvedGuild) {
-          cacheGuildChannel(resolvedGuild.channels.cache, channel);
-        }
-      }
+  static create(
+    client: Client,
+    data: RawChannelData,
+    guild?: Guild | null,
+    { allowUnknownGuild = false }: { allowUnknownGuild?: boolean } = {}
+  ) {
+    const { channel, relations } = constructChannel(client, data, guild, {
+      allowUnknownGuild,
+    });
+    if (!channel) {
+      return channel;
+    }
+    if (!allowUnknownGuild && relations.guild) {
+      relations.guild.channels.cache.set(channel.id, channel as never);
+    }
+    if (!allowUnknownGuild && relations.threadParent) {
+      const parent = relations.threadParent as {
+        threads?: { cache?: Map<string, Channel> };
+      };
+      parent.threads?.cache?.set(channel.id, channel);
     }
     return channel;
   }

package/src/structures/ChannelConstruction.ts

@@ -0,0 +1,177 @@
+import { createRequire } from 'node:module';
+
+const require = createRequire(import.meta.url);
+import type { Client } from '../client/Client';
+import type { Guild } from './Guild';
+import type { RawChannelData } from '../../typings/rawDataTypes';
+import _ConstantsModule from '../util/Constants';
+import { isThreadParentChannel } from '../types/channels';
+import type { Channel } from './Channel';
+
+const { ChannelTypes } = _ConstantsModule;
+
+type GuildChannelConstructor = new (
+  guild: Guild,
+  data: RawChannelData,
+  client: Client
+) => Channel;
+
+type ClientChannelConstructor = new (
+  client: Client,
+  data: RawChannelData
+) => Channel;
+
+let channelFactory:
+  | ((
+      client: Client,
+      data: RawChannelData,
+      guild?: Guild
+    ) => Channel | undefined)
+  | null = null;
+
+function requireGuild(guild: Guild | null | undefined): Guild {
+  if (!guild) {
+    throw new TypeError('A guild is required to create a guild channel');
+  }
+  return guild;
+}
+
+function buildChannelFactory() {
+  const CategoryChannel = require('./CategoryChannel')
+    .default as GuildChannelConstructor;
+  const DMChannel = require('./DMChannel').default as ClientChannelConstructor;
+  const GroupDMChannel = require('./GroupDMChannel')
+    .default as ClientChannelConstructor;
+  const NewsChannel = require('./NewsChannel')
+    .default as GuildChannelConstructor;
+  const StageChannel = require('./StageChannel')
+    .default as GuildChannelConstructor;
+  const StoreChannel = require('./StoreChannel')
+    .default as GuildChannelConstructor;
+  const TextChannel = require('./TextChannel')
+    .default as GuildChannelConstructor;
+  const ThreadChannel = require('./ThreadChannel')
+    .default as GuildChannelConstructor;
+  const VoiceChannel = require('./VoiceChannel')
+    .default as GuildChannelConstructor;
+  const DirectoryChannel = require('./DirectoryChannel')
+    .default as ClientChannelConstructor;
+  const ForumChannel = require('./ForumChannel')
+    .default as GuildChannelConstructor;
+  const MediaChannel = require('./MediaChannel')
+    .default as GuildChannelConstructor;
+
+  const constructDirect = (
+    client: Client,
+    data: RawChannelData
+  ): Channel | undefined => {
+    if (
+      ('recipients' in data &&
+        data.recipients &&
+        data.type !== ChannelTypes.GROUP_DM) ||
+      data.type === ChannelTypes.DM
+    ) {
+      return new DMChannel(client, data);
+    }
+    if (data.type === ChannelTypes.GROUP_DM) {
+      return new GroupDMChannel(client, data);
+    }
+    return undefined;
+  };
+
+  const constructGuild = (
+    client: Client,
+    data: RawChannelData,
+    guild?: Guild
+  ): Channel | undefined => {
+    switch (data.type) {
+      case ChannelTypes.GUILD_TEXT: {
+        return new TextChannel(requireGuild(guild), data, client);
+      }
+      case ChannelTypes.GUILD_VOICE: {
+        return new VoiceChannel(requireGuild(guild), data, client);
+      }
+      case ChannelTypes.GUILD_CATEGORY: {
+        return new CategoryChannel(requireGuild(guild), data, client);
+      }
+      case ChannelTypes.GUILD_NEWS: {
+        return new NewsChannel(requireGuild(guild), data, client);
+      }
+      case ChannelTypes.GUILD_STORE: {
+        return new StoreChannel(requireGuild(guild), data, client);
+      }
+      case ChannelTypes.GUILD_STAGE_VOICE: {
+        return new StageChannel(requireGuild(guild), data, client);
+      }
+      case ChannelTypes.GUILD_NEWS_THREAD:
+      case ChannelTypes.GUILD_PUBLIC_THREAD:
+      case ChannelTypes.GUILD_PRIVATE_THREAD: {
+        return new ThreadChannel(requireGuild(guild), data, client);
+      }
+      case ChannelTypes.GUILD_DIRECTORY: {
+        return new DirectoryChannel(client, data);
+      }
+      case ChannelTypes.GUILD_FORUM: {
+        return new ForumChannel(requireGuild(guild), data, client);
+      }
+      case ChannelTypes.GUILD_MEDIA: {
+        return new MediaChannel(requireGuild(guild), data, client);
+      }
+      default: {
+        return undefined;
+      }
+    }
+  };
+
+  return (client: Client, data: RawChannelData, guild?: Guild) => {
+    const guildId = 'guild_id' in data ? data.guild_id : undefined;
+    if (!guildId && !guild) {
+      return constructDirect(client, data);
+    }
+    return constructGuild(client, data, guild);
+  };
+}
+
+export interface ConstructedChannelRelations {
+  guild?: Guild;
+  threadParent?: unknown;
+}
+
+export function constructChannel(
+  client: Client,
+  data: RawChannelData,
+  guild?: Guild | null,
+  { allowUnknownGuild = false }: { allowUnknownGuild?: boolean } = {}
+): { channel: Channel | undefined; relations: ConstructedChannelRelations } {
+  channelFactory ??= buildChannelFactory();
+
+  const relations: ConstructedChannelRelations = {};
+  const guildId = 'guild_id' in data ? data.guild_id : undefined;
+  if (!guildId && !guild) {
+    return { channel: channelFactory(client, data), relations };
+  }
+
+  const resolvedGuild =
+    guild ?? (guildId ? client.guilds.cache.get(guildId) : undefined);
+
+  if (!resolvedGuild && !allowUnknownGuild) {
+    return { channel: undefined, relations };
+  }
+
+  const channel = channelFactory(client, data, resolvedGuild);
+  if (channel && resolvedGuild) {
+    relations.guild = resolvedGuild;
+  }
+  if (
+    channel &&
+    typeof channel.isThread === 'function' &&
+    channel.isThread() &&
+    'parent' in channel &&
+    channel.parent &&
+    isThreadParentChannel(channel.parent as never)
+  ) {
+    relations.threadParent = channel.parent;
+  }
+
+  return { channel, relations };
+}

package/src/structures/interfaces/TextBasedChannel.ts

@@ -11,6 +11,7 @@ import SnowflakeUtil from '../../util/SnowflakeUtil';
 import { setTimeout } from 'node:timers';
 import { s } from '@sapphire/shapeshift';
 import Util from '../../util/Util';
+import { uploadMessageAttachments } from '../../util/OutboundMessagePipeline';
 import User from '../User';
 import _GuildMemberModule from '../GuildMember';
 
@@ -27,7 +28,6 @@ import type {
 } from '../../../typings';
 import type { SendOptions } from '../../types/channels';
 import type { RawMessageData } from '../../../typings/rawDataTypes';
-import type { UploadAttachment } from '../../types/uploads';
 import type ClientType from '../../client/Client';
 import type { Guild } from '../Guild';
 
@@ -615,30 +615,10 @@ class TextBasedChannel {
         : MessagePayload.create(this, options).resolveData();
 
     const { data, files } = await messagePayload.resolveFiles();
-    const fileList = files ?? [];
-    // New API
-    const attachments = await Util.getUploadURL(this.client, this.id, fileList);
-    const requestPromises = attachments.map(
-      async (attachment: UploadAttachment) => {
-        const file = fileList[Number(attachment.id)];
-        if (!file) {
-          throw new Error('INVALID_TYPE', 'attachment', 'FileOptions');
-        }
-        await Util.uploadFile(file.file, attachment.upload_url);
-        return {
-          description: file.description,
-          duration_secs: file.duration_secs,
-          filename: file.name,
-          id: attachment.id,
-          uploaded_filename: attachment.upload_filename,
-          waveform: file.waveform,
-        };
-      }
-    );
-    const attachmentsData = await Promise.all(requestPromises);
-    attachmentsData.sort(
-      (left, right) =>
-        Math.trunc(Number(left.id)) - Math.trunc(Number(right.id))
+    const attachmentsData = await uploadMessageAttachments(
+      this.client,
+      this.id,
+      files ?? []
     );
     if (data) {
       Object.assign(data, { attachments: attachmentsData });

package/src/util/OutboundMessagePipeline.ts

@@ -0,0 +1,54 @@
+import Util from './Util';
+import type { Client } from '../client/Client';
+import type { HTTPAttachmentData } from '../../typings';
+import type { UploadAttachment } from '../types/uploads';
+
+export interface UploadedMessageAttachment {
+  description?: string;
+  duration_secs?: number;
+  filename: string;
+  id: string;
+  uploaded_filename: string;
+  waveform?: string;
+}
+
+export async function uploadMessageAttachments(
+  client: Client,
+  channelId: string,
+  files: HTTPAttachmentData[]
+): Promise<UploadedMessageAttachment[]> {
+  if (!files.length) {
+    return [];
+  }
+
+  const uploads = (await Util.getUploadURL(
+    client,
+    channelId,
+    files
+  )) as UploadAttachment[];
+
+  const attachments = await Promise.all(
+    uploads.map(async (upload: UploadAttachment) => {
+      const file = files[Number(upload.id)];
+      if (!file) {
+        throw new TypeError('Invalid upload attachment index');
+      }
+      await Util.uploadFile(file.file, upload.upload_url);
+      return {
+        description: file.description,
+        duration_secs: file.duration_secs,
+        filename: file.name,
+        id: upload.id,
+        uploaded_filename: upload.upload_filename,
+        waveform: file.waveform,
+      } satisfies UploadedMessageAttachment;
+    })
+  );
+
+  attachments.sort(
+    (left, right) => Math.trunc(Number(left.id)) - Math.trunc(Number(right.id))
+  );
+  return attachments;
+}
+
+export default { uploadMessageAttachments };