April/functions.mjs

import { REST }  from "@discordjs/rest";
import { Routes }  from "discord-api-types/v10";
import { Collection, WebhookClient, EmbedBuilder, Client }  from 'discord.js';
import { inspect }  from "util";
import fs  from "fs";
import Sequelize  from "sequelize";

import config from './config.json' assert { type: 'json' };
const { token, clientId, guildId, sequelizeCredentials, errorWebhookURL } = config;


const rest = new REST({ version: '10' }).setToken(token);




async function deploy_commands(client, loadcommands) {
    if (typeof loadcommands !="boolean" && loadcommands != null) throw "loadcommands argument needs to be boolean or null";

    const commands = [];
    client.commands = new Collection();
    const commandCategories = fs.readdirSync('./commands').filter(file => !file.includes('.'));
    console.log(`Loading ${commandCategories.toString()} commands...`);
    for (const category of commandCategories) {
        const commandFiles = fs.readdirSync(`./commands/${category}`).filter(file => file.endsWith('.mjs'));
        console.log(`Loading ${commandFiles.toString()}...`);
        for (const file of commandFiles) {
            const { default: command } = await import(`./commands/${category}/${file}`);
            commands.push(command.data);
            client.commands.set(command.data.name, command);

            console.log(`${category}/${command.data.name} chargé !`);
        }
    }
    if (loadcommands==true){
        slashCommandLoad(client, commands);
        console.log("Refreshed slash commands !");
    }
    else if(loadcommands==false){//Deletes slash commands
        slashCommandLoad(client, []);
        console.log("Deleted slash commands !");
    }
    else{
        console.log("Kept old commands");
    }
};


async function slashCommandLoad(client, commands) {
    try {
        console.log('Je commence à actualiser les commandes slash.');
        await rest.put(
            Routes.applicationGuildCommands(clientId, guildId),
            { body: commands },
        );    
        console.log('Je viens de terminer de charger les commandes slash.');
    } catch (error) {
        console.error(error);
    }
    return client.commands;
};


function loadDatabase(client) {
    console.log("Starting to load database...");
    const sequelize = new Sequelize('database', sequelizeCredentials.username, sequelizeCredentials.password, {
        host: 'localhost',
        dialect: 'sqlite',
        logging: false,
        storage: 'database.sqlite',
    });
    const blacklistdb = sequelize.define('blacklist', {
        name: {//id
            type: Sequelize.STRING,
            unique: true,
        },
        username: Sequelize.STRING,
        reason: Sequelize.TEXT,
        timestamp: Sequelize.STRING,
        moderatorid: Sequelize.STRING
    });
    
    const modlog = sequelize.define('sanctions', {
        name: Sequelize.STRING,//id
        username: Sequelize.STRING,
        type: Sequelize.STRING,
        reason: Sequelize.TEXT,
        timestamp: Sequelize.STRING,
        moderatorid: Sequelize.STRING
    });
    
    const artists = sequelize.define('artists', {
        name: Sequelize.STRING,//id
        emoji: Sequelize.STRING,
    });
    
    client.database = {
        sequelize: sequelize,
        modlog: modlog,
        blacklistdb: blacklistdb,
        artists: artists,
    };
    blacklistdb.sync();
    modlog.sync();
    artists.sync();
    console.log("Database loaded !");
}

function loadErrorCatcher(client) {
    console.log("Loading error catcher...");
    client.errorCatcherWebhook = new WebhookClient({
        url: errorWebhookURL,
    });

    process.on("unhandledRejection", (reason, promise) => {
        console.log(reason, "\n", promise);

        const errorEmbed = new EmbedBuilder()
            .setColor("Red")
            .setTitle("Unhandled Rejection/Catch")
            .setURL("https://nodejs.org/api/process.html#event-unhandledrejection")
            .addFields(
                {
                    name: "Reason",
                    value: `\`\`\`${inspect(reason, { depth: 0 }).slice(0, 1000)}\`\`\``,
                },
                {
                    name: "Promise",
                    value: `\`\`\`${inspect(promise, { depth: 0 }).slice(0, 1000)}\`\`\``,
                }
            )
            .setTimestamp();

        return client.errorCatcherWebhook.send({ embeds: [errorEmbed] });
    });

    process.on("uncaughtException", (err, origin) => {
        console.log(err, "\n", origin);

        const errorEmbed = new EmbedBuilder()
            .setColor("Red")
            .setTitle("Uncaught Exception/Catch")
            .setURL("https://nodejs.org/api/process.html#event-uncaughtexception")
            .addFields(
                {
                    name: "Error",
                    value: `\`\`\`${inspect(err, { depth: 0 }).slice(0, 1000)}\`\`\``,
                },
                {
                    name: "Origin",
                    value: `\`\`\`${inspect(origin, { depth: 0 }).slice(0, 1000)}\`\`\``,
                }
            )
            .setTimestamp();

        return client.errorCatcherWebhook.send({ embeds: [errorEmbed] });
    });

    process.on("uncaughtExceptionMonitor", (err, origin) => {
        console.log(err, "\n", origin);

        const errorEmbed = new EmbedBuilder()
            .setColor("Red")
            .setTitle("Uncaught Exception Monitor")
            .setURL(
                "https://nodejs.org/api/process.html#event-uncaughtexceptionmonitor"
            )
            .addFields(
                {
                    name: "Error",
                    value: `\`\`\`${inspect(err, { depth: 0 }).slice(0, 1000)}\`\`\``,
                },
                {
                    name: "Origin",
                    value: `\`\`\`${inspect(origin, { depth: 0 }).slice(0, 1000)}\`\`\``,
                }
            )
            .setTimestamp();

        return client.errorCatcherWebhook.send({ embeds: [errorEmbed] });
    });

    process.on("warning", (warn) => {
        console.log(warn);

        const errorEmbed = new EmbedBuilder()
            .setColor("Red")
            .setTitle("Uncaught Exception Monitor Warning")
            .setURL("https://nodejs.org/api/process.html#event-warning")
            .addFields({
                name: "Warning",
                value: `\`\`\`${inspect(warn, { depth: 0 }).slice(0, 1000)}\`\`\``,
            })
            .setTimestamp();

        return client.errorCatcherWebhook.send({ embeds: [errorEmbed] });
    });

    console.log("Error catcher loaded !");
}

export { deploy_commands, loadDatabase, loadErrorCatcher }