bot base

server/structures/client.ts

@@ -0,0 +1,95 @@
+import { ApplicationCommandDataResolvable, Client, ClientOptions, Collection, GatewayIntentBits, Guild, IntentsBitField, Snowflake } from "discord.js";
+import { CommandType } from "../types/commandTypes";
+import fs from 'fs'
+import { config } from "../configuration";
+
+export class ExtendedClient extends Client {
+  private eventFilePath = `${__dirname}/../events`
+  private commandFilePath = `${__dirname}/../commands`
+  public commands: Collection<string, CommandType> = new Collection()
+  public constructor() {
+    const intents: IntentsBitField = new IntentsBitField()
+    intents.add(IntentsBitField.Flags.GuildMembers, IntentsBitField.Flags.MessageContent, IntentsBitField.Flags.Guilds, IntentsBitField.Flags.DirectMessages)
+    const options: ClientOptions = { intents }
+    super(options)
+  }
+  public start() {
+    if (process.env.NODE_ENV === 'test') return
+    const promises: Promise<any>[] = Array()
+    promises.push(this.registerSlashCommands())
+    promises.push(this.registerEventCallback())
+    Promise.all(promises).then(() => {
+      this.login(config.token)
+    })
+  }
+  private async importFile(filepath: string): Promise<any> {
+    console.debug(`Importing ${filepath}`)
+    const imported = await import(filepath)
+    console.debug(`Imported ${JSON.stringify(imported)}`)
+    return imported.default ?? imported
+  }
+  public async registerCommands(cmds: ApplicationCommandDataResolvable[], guildIds: Collection<Snowflake, Guild>) {
+    if (guildIds) {
+      guildIds.forEach(guild => {
+        this.guilds.cache.get(guild.id)?.commands.set(cmds)
+        console.log(`Registering commands to ${guild.name}|${guild.id}`)
+      })
+    } else {
+      this.application?.commands.set(cmds)
+      console.log(`Registering global commands`)
+    }
+    return
+  }
+  public async registerSlashCommands(): Promise<void> {
+    try {
+      const slashCommands: ApplicationCommandDataResolvable[] = []
+      const commandFiles = fs.readdirSync(this.commandFilePath).filter(file => file.endsWith('.ts') || file.endsWith('.js'))
+      for (const commandFile of commandFiles) {
+        const filePath = `${this.commandFilePath}/${commandFile}`
+        const command = await this.importFile(filePath)
+        console.debug(JSON.stringify(command))
+        if (!command.name) return
+        console.debug(command)
+        this.commands.set(command.name, command)
+        slashCommands.push(command)
+      }
+      this.on("ready", (client: Client) => {
+        //console.log(`Ready processing ${JSON.stringify(client)}`)
+        console.log(`SlashCommands: ${JSON.stringify(slashCommands)}`)
+        const guilds = client.guilds.cache
+        this.registerCommands(slashCommands, guilds)
+        this.cacheUsers(guilds)
+      })
+    } catch (error) {
+      console.log(`Error refreshing slash commands: ${error}`)
+    }
+  }
+  public async cacheUsers(guilds: Collection<Snowflake, Guild>) {
+    guilds.forEach((guild:Guild, id:Snowflake) => {
+      console.log(`Fetching members for ${guild.name}|${id}`)
+      guild.members.fetch()
+      console.log(`Fetched: ${guild.memberCount} members`)
+    })
+
+  }
+  public async registerEventCallback() {
+    try {
+      const eventFiles = fs.readdirSync(this.eventFilePath).filter(file => file.endsWith('.ts') || file.endsWith('.js'));
+      for (const file of eventFiles) {
+        const filePath = `${this.eventFilePath}/${file}`
+        const event = await this.importFile(filePath)
+        if (event.once) {
+          console.log(`Registering once ${file}`)
+          this.once(event.name, (...args: any[]) => event.execute(...args))
+        }
+        else {
+          console.log(`Registering on ${file}`)
+          this.on(event.name, (...args: any[]) => event.execute(...args))
+        }
+      }
+      console.log(this.eventNames())
+    } catch (error) {
+      console.error(error)
+    }
+  }
+}

server/structures/command.ts

@@ -0,0 +1,7 @@
+import { CommandType } from "../types/commandTypes";
+
+export class Command {
+	constructor(commandOptions: CommandType) {
+		Object.assign(this, commandOptions)
+	}
+}

server/structures/event.ts

@@ -0,0 +1,8 @@
+import { ClientEvents } from "discord.js";
+
+export class Event<Key extends keyof ClientEvents>{
+  constructor(
+    public event: Key,
+    public run: (...args: ClientEvents[Key]) => unknown
+  ) { }
+}