node-event-bot/server/structures/client.ts

import { ApplicationCommandDataResolvable, Client, Collection, Guild, Intents, 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() {
		super({ intents: [Intents.FLAGS.GUILDS, Intents.FLAGS.GUILD_SCHEDULED_EVENTS] })
	}
	public start() {
		const promises = []
		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}|${guild.id}`)
			})
		} else {
			this.application?.commands.set(cmds)
			console.log(`Registering global commands`)
		}
		return
	}
	public async registerSlashCommands() {
		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)
			})
		} catch (error) {
			console.log(`Error refreshing slash commands: ${error}`)
		}
	}
	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)
		}
	}
}