Discord.js-managers NPM

discord.js-managers

About

A package to synchronize your bot's commands and events and managing interactions

Quickly registers new Commands
Auto deletes deleted Commands
Managing Interactions
Managing events

Changed

critical bugs fixed 1.0.0
fixed a few bugs 1.0.1
added cooldown system 1.1.0
critical bugs fixed 1.1.1

Instaling discord.js-managers

npm i discord.js-managers

Example Usage

Create a main file

index.js (example)

import { Client, GatewayIntentBits } from 'discord.js'
import Handler from "discord.js-managers"

const client = new Client({ intents: [GatewayIntentBits.Guilds] })
const handler = new Handler({ 
    client: client,
    commandsFolder: "commandsFolder",
    eventsFolder: "eventsFolder",
    consoleLogging: true, 
    checkUpdate: true 
})

handler.commands.synchronize()
handler.events.synchronize()

client.login(TOKEN);

Create a command folder with the name you entered in the commandsFolder property
Create a event folder with the name you entered in the eventsFolder property

Add Command

Create a javascript file in the your commandsFolder
Fill in name, description [Only chatInput] and execute [function] as forced in

export default {
	name: "test",
	description: "Test Command",
	execute(client, interaction, options) {
		interaction.reply("Test successful")
	}
}

Optionally, type [default: 1], cooldown ,guild, permission, options, componentInteraction [function], autocompleteInteraction [function], modalInteraction [function]

export default {
	type: 1,
	name: "test",
	description: "Test Command",
	cooldown: 5,
	guild: 895139517651258664,
	options: [
		{
			type: 3,
			name: "test_option",
			description: "Test",
			autocomplete: true
		}
	],
	permissions: [
		"BanMembers",
		"KickMembers"
	],
	execute(client, interaction, options) {
		const component = {
			type: 1, // ActionRow
			components: [
				{
					type: 2, // Button
					customId: "test.button",
					label: "Pong!",
					style: 1
				}
			]
		}
		
		interaction.reply({ components: [component] }).then(() => {
			interaction.followUp(`option: ${options.getString("test_option")}`)
		})
	},
	componentInteraction(client, interaction, customId) {
		if (customId == "button") {
			const modal = {
			title: "Test Modal",
			customId: "test.modal",
			components: [
				{
					type: 1,
					components: [
						{
							type: 4,
							customId: "test",
							label: "Test Modal",
							style: 1,
							placeholder: "Test"
						}
					]
				}
			]
		}
		interaction.showModal(modal)
		}
	},
	autocompleteInteraction(client, interaction, focused) {
		interaction.respond(
			[
				{
					name: "test",
					value: "test"
				}
			]
		)
	},
	modalInteraction(client, interaction, customId) {
		interaction.reply("Modal triggered!")
	}
}

Add Event

Make the name of the javascript file the name of the event you want to add
First export the client and then the objects to be rendered with the default

export default (client, role) => { ··· }

Handling Components

First, let's create a sample component.
To handle interactions, prefix the customId property with the name of the command as in the example.

const component = {
	type: 1,
	components: [
		{
			type: 2,
			customId: "ping.button",
			label: "Pong!",
			style: 1
		}
	]
}

Then create a function called componentInteraction inside the command file and send client, interaction and customId arguments from the function.
Enter the codes you want to run when the component inside the function is triggered

export default {
	name: 'ping',
	description: 'Replies with Pong',
	execute(client, interaction, options) {
		const component = {
			type: 1, // ActionRow
			components: [
				{
					type: 2, // Button
					customId: "ping.button",
					label: "Pong!",
					style: 1
				}
			]
		}
		
		interaction.reply({ components: [component] })
	},
	componentInteraction(client, interaction, customId) {
		interaction.reply("Component triggered!")
	}
}

If you have more than one component, you can check it customId (Do not write the command name where it starts).

export default {
	name: 'ping',
	description: 'Replies with Pong',
	execute(client, interaction, options) {
		const component = {
			type: 1, // ActionRow
			components: [
				{
					type: 2, // Button
					customId: "ping.button",
					label: "Pong!",
					style: 1
				}
			]
		}
		
		interaction.reply({ components: [component] })
	},
	componentInteraction(client, interaction, customId) {
		if (customId == "button") {
			interaction.reply("Component triggered!")
		}
	}
}

Handling Autocomplete

First, let's create a sample autocomplete.

export default {
	name: 'ping',
	description: 'Replies with Pong',
	options: [
		{
			name: "test",
			description: "Test autocomplate option",
			type: 3,
			autocomplete: true,
			required: true
		}
	],
	execute(client, interaction, options) {
		interaction.reply("Pong!")
	}
}

Then create a function called autocompleteInteraction inside the command file and send client, interaction and focused arguments from the function.

export default {
	name: 'ping',
	description: 'Replies with Pong',
	options: [
		{
			name: "test",
			description: "Test autocomplate option",
			type: 3,
			autocomplete: true,
			required: true
		}
	],
	execute(client, interaction, options) {
		interaction.reply("Pong!")
	},
	autocompleteInteraction(client, interaction, focused) {
		interaction.respond(
			[
				{
					name: "test",
					value: "test"
				}
			]
		)
	}
}

Each time autocomplete is called the function will run and the focused value will be returned.

export default {
	name: 'ping',
	description: 'Replies with Pong',
	options: [
		{
			name: "test",
			description: "Test autocomplate option",
			type: 3,
			autocomplete: true,
			required: true
		}
	],
	execute(client, interaction, options) {
		interaction.reply("Pong!")
	},
	autocompleteInteraction(client, interaction, focused) {
		console.log(focused)
	}
}

Handling Modals

First, let's create a sample modal.
To handle interactions, prefix the customId property with the name of the command as in the example.

export default {
	name: 'ping',
	description: 'Replies with Pong',
	execute(client, interaction, options) {
		const modal = {
			title: "Test Modal",
			customId: "ping.modal",
			components: [
				{
					type: 1,
					components: [
						{
							type: 4,
							customId: "test",
							label: "Test Modal",
							style: 1,
							placeholder: "Test"
						}
					]
				}
			]
		}
		interaction.showModal(modal)
	}
}

Then create a function called modalInteraction inside the command file and send client, interaction and customId arguments from the function.
Enter the codes you want to run when the modal inside the function is triggered

export default {
	name: 'ping',
	description: 'Replies with Pong',
	execute(client, interaction, options) {
		const modal = {
			title: "Test Modal",
			customId: "ping.modal",
			components: [
				{
					type: 1,
					components: [
						{
							type: 4,
							customId: "test",
							label: "Test Modal",
							style: 1,
							placeholder: "Test"
						}
					]
				}
			]
		}
		interaction.showModal(modal)
	},
	modalInteraction(client, interaction, customId) {
		interaction.reply("Modal triggered!")
	}
}

If you have more than one modal, you can check it customId (Do not write the command name where it starts).

export default {
	name: 'ping',
	description: 'Replies with Pong',
	execute(client, interaction, options) {
		const modal = {
			title: "Test Modal",
			customId: "ping.modal",
			components: [
				{
					type: 1,
					components: [
						{
							type: 4,
							customId: "test",
							label: "Test Modal",
							style: 1,
							placeholder: "Test"
						}
					]
				}
			]
		}
		interaction.showModal(modal)
	},
	modalInteraction(client, interaction, customId) {
		if (customId == "modal") {
			interaction.reply("Modal triggered!")
		}
	}
}

Command Functions

\.commands.create({ type, name, ... })

You can create new commands from within the file you want
Forced parameters; name, description [only for chatInput commands], execute [function]
Optionally parameters; type, cooldown, guild, permissions, options, componentInteraction [function], autocompleteInteraction [function], modalInteraction [function]

<handler>.commands.create({
  //type: 1,
	name: "test",
	description: "Test Command",
  //cooldown: 5,
  //guild: 895···42,
  //options: [ ··· ],
  //permissions: [ ··· ],
	execute(client, interaction, options) {
		interaction.reply("Test!")
	},
  //componentInteraction(client, interaction, customId) { ··· },
  //autocompleteInteraction(client, interaction, focused) { ··· },
  //modalInteraction(client, interaction, customId) { ··· }
})

\.commands.get(commandName, callback() => {})

Get information of the command with the name of your command
Returns the information of the promise command or you can use the callback

<handler>.commands.get("test", command => {
	console.log(command)
})

// or
<handler>.commands.get("test").then(command => {
	console.log(command)
})

// Console Output:
{
	name: "test",
	description: "Test Command",
	execute: [Function: execute]
}

\.commands.has(commandName, callback() => {})

Checks whether your command exists with the name you entered.
returns promise boolean or you can use the callback

<handler>.commands.has("test", command => {
	console.log(command)
})

// or
<handler>.commands.has("test").then(command => {
	console.log(command)
})

// Console Output:
true

\.commands.delete(commandName, callback() => {})

Deletes of the command with the name of your command
Returns the information of the promise command or you can use the callback

<handler>.commands.delete("test", command => {
	console.log(command)
})

// or
<handler>.commands.delete("test").then(command => {
	console.log(command)
})

// Console Output:
{
	name: "test",
	description: "Test Command",
	execute: [Function: execute]
}

Event Functions

\.events.create(event, eventListener function)

You can create new events from within the file you want
Forced parameters; event, eventListener [function]

<handler>.events.create("roleCreate", (role) => { ··· })

\.events.get(event, callback() => {})

Get event's function with the name of your event
Returns the function of the promise event function or you can use the callback

<handler>.events.get("ready", eventFunc => {
	console.log(eventFunc.toString())
})

// or
<handler>.events.get("ready").then(eventFunc => {
	console.log(eventFunc.toString())
})

// Console Output:
(client) => { ··· }

\.events.has(event, callback() => {})

Checks whether your event exists with the name you entered.
returns promise boolean or you can use the callback

<handler>.events.has("ready", isEvent => {
	console.log(isEvent)
})

// or
<handler>.events.has("ready").then(isEvent => {
	console.log(isEvent)
})

// Console Output:
true