Merge branch 'ts-dev'

Author: pauldb09

README.md

@@ -92,11 +92,11 @@ When your terminal is created, write `npm install` in your terminal to download
 If you encounter any error, make you sure that you have the latest version of nodejs or ask in the discord server.
 
 __Step 3.__
-When the modules have been downloaded and a `node-modules` directory has been created, go to the `config.js` file and setup the bot.
+When the modules have been downloaded and a `node-modules` directory has been created, go to the `config.ts` file in the `src` folder and setup the bot.
 You can find some comments about every setting.
 
 __Step 4.__
-Now, you can start the bot by pressing `F5` or putting `node index.js` in the terminal.
+Now, you can start the bot by pressing `F5` or putting `npm run start` in the terminal.
 
 __Step 5.__
 Enjoy your bot !

index.js

@@ -0,0 +1,46 @@
+    //IMPORTANT: If you need help with the installation of Green-bot, you can join my server here: https://discord.gg/Q5QSbAHaXB for help
+
+
+import { Manager, ReClusterManager } from "discord-hybrid-sharding";
+import config from "./module/config";
+
+const manager = new Manager("./module/src/cluster.js", {
+    mode: "process",
+    token: config.token,
+    shardsPerClusters: 10
+});
+
+manager.extend(
+    new ReClusterManager({
+        delay: 2000,
+        timeout: -1,
+        restartMode: 'gracefulSwitch',
+    })
+)
+
+manager.on("clusterCreate", (cluster) => {
+    cluster.on("ready" ,()=>{
+        if(config.debug) console.log("[Cluster Manager ==> Cluster] Cluster \""+cluster.id+"\" entered ready")
+    })
+    cluster.on("reconnecting",()=>{
+        if(config.debug) console.log("[Cluster Manager ==> Cluster] Cluster \""+cluster.id+"\" is reconnecting to discord WS")
+    })
+    cluster.on('message', message => {
+        console.log(message);
+       if(message === "restart"){
+        manager.recluster.start(  {
+            delay: 2000,
+            timeout: -1,
+            shardsPerClusters: 15,
+            restartMode: 'gracefulSwitch'
+        } );
+    }
+    })
+    if(config.debug) console.log("[Cluster Manager ==> Cluster] Cluster \""+cluster.id+"\" created")
+})
+
+manager
+.spawn({ timeout: -1 })
+.then(() => {
+    console.log("[Cluster Manager] The bot is now ready and all shards are connected to discord Websocked.\nCurrent Debug Mode is set to: "+config.debug+"")
+})

index.ts

@@ -0,0 +1,46 @@
+const { REST } = require('@discordjs/rest');
+const { Routes } = require('discord-api-types/v9');
+import config from "./config"
+import { readdirSync } from "fs";
+
+const { token } = require('./config.js');
+console.log('• Loading the commands to refresh');
+// the current amount of commands to refresh
+const commands = [];
+const x=-1;
+// peseudo load the commands to get the interaction data
+const files = readdirSync(`${__dirname}/src/interactions`, { withFileTypes: true });
+files.forEach(cat => {
+    const dirFiles = readdirSync(`${__dirname}/src/interactions/${cat.name}`, { withFileTypes: true });
+    dirFiles.forEach(async cmd => {
+        if (cmd.name.endsWith(".map")) return;
+        try {
+            const command = new ((await import(`${__dirname}/src/interactions/${cat.name}/${cmd.name}`)).default)
+           commands.push({
+            name: command.name,
+            description: command.description,
+            options: command.arguments,
+           })
+           console.log(commands)
+        } catch (error) {
+            console.log(`[Command Handler] Cannot load file ${cmd.name}. Missing export default?: ${error}`)
+        }
+       
+    })
+})
+// stuffs are loaded, now lets log how many commands we have
+setTimeout(()=>{
+    console.log(`• Loaded ${commands.length} slash commands to refresh`);
+// as per d.js guide, create a rest client
+const rest = new REST({ version: '9' }).setToken(config.token);
+// start the load up process
+(async () => {
+    try {
+        console.log(`• Refreshing client "946414667436269579" slash commands. Developer Mode? `);
+            await rest.put(Routes.applicationCommands(config.botId), { body: commands });
+        console.log(`• Success! Refreshed client "946414667436269579" slash commands`);
+    } catch (error) {
+        console.error(error);
+    }
+})();
+})

module/SlashUpdate.ts

@@ -1,17 +1,20 @@
-module.exports = {
-    //IMPORTANT: If you need help with the installation of Green-bot, you can join our support server here: https://green-bot.app/discord
+export default {
+    //IMPORTANT: If you need help with the installation of Green-bot, you can join my server here: https://discord.gg/Q5QSbAHaXB for help
     // Complete it carefuly else it won't work, check the readme for more informations
     lavalink: [
         { name: "1", url: "LAVALINK_IP:PORT", auth: "LAVALINK_AUTH", secure: null },
     ],
+    // Sends a lot of info into console.
+    debug: false,
+    botId: "",
     // The prefix used to answer to commands
     prefix: "*",
     // Optional, for loading playlists with more than 100 tracks ( Else using a scaper )
     spotify: { clientId: "", clientSecret: "", cacheResults: !0, cacheLifetime: 36e5 },
     // The wrapper used to connect to the lavalink server: https://deivu.github.io/Shoukaku
     shoukaku: { moveOnDisconnect: !0, resumable: !0, closedEventDelay: 1e3, resumableTimeout: 500, reconnectTries: 5, restTimeout: 3e4 },
     // The database. Create a database on Atlas/ Your vps and copy the connection url here. Additional informations: https://www.mongodb.com/
-    database: {
+    mongo: {
         url: "mongodb://localhost:27017/test",
         options: {
             maxPoolSize: 200,

config.js renamed to module/config.ts

@@ -0,0 +1,194 @@
+import * as Eris from "eris";
+import dbl from "dblapi.js";
+import { ShoukakuHandler } from "./modules/ShoukakuHandler";
+import { QueueManager } from "./modules/Queue";
+import { EventHandler } from "./modules/EventHandler";
+import { Spotify } from "@tuneorg/spotify";
+import { CommandLoader } from "./modules/CommandHandler";
+import { DatabaseManager } from "./modules/DatabaseManager";
+import { BaseError } from "./abstract/BaseListener";
+import { Server } from "./modules/server";
+import { CommandManager } from "./modules/CommandService";
+import { voiceService } from "./modules/voiceService";
+import { Client } from "discord-hybrid-sharding";
+import { SlashManager } from "./modules/buttonHandler";
+import { CollectorManager } from "./modules/Collector";
+import { sweeperManager } from "./modules/sweeperManager";
+import { Context } from "./modules/Context";
+import { SlashContext } from "./modules/SlashContext";
+const Cluster = require("discord-hybrid-sharding");
+
+
+export class BaseDiscordClient extends Eris.Client {
+    location: string;
+    commands: CommandLoader;
+    commandManager: CommandManager;
+    database: DatabaseManager;
+    config: any;
+    collectors: CollectorManager;
+    cluster: Client;
+    voiceHandler: voiceService;
+    shoukaku: ShoukakuHandler;
+    dbl: dbl;
+    events: EventHandler;
+    server?: Server;
+    sweepers: sweeperManager;
+    spotify: Spotify;
+    slashManager: SlashManager;
+    queue: QueueManager;
+    constructor(options: any) {
+
+        // Passing options for the eris client
+        super(options.token,
+            {
+                firstShardID: Cluster.data.FIRST_SHARD_ID,
+                lastShardID: Cluster.data.LAST_SHARD_ID,
+                maxShards: Cluster.data.TOTAL_SHARDS,
+                restMode: true,
+                largeThreshold: 1000000,
+                guildCreateTimeout: 1000,
+                allowedMentions: { everyone: false, roles: false, users: false },
+                autoreconnect: true,
+                intents: ["guilds", "guildVoiceStates", "guildMessages"],
+                connectionTimeout: 40000,
+                maxResumeAttempts: 40,
+                messageLimit: 0,
+                disableEvents: {
+                    "TYPING_START": true,
+                    "USER_NOTE_UPDATE": true,
+                    "CHANNEL_PINS_UPDATE": true,
+                    "MESSAGE_UPDATE": true,
+                    "RELATIONSHIP_ADD": true,
+                    "RELATIONSHIP_REMOVE": true,
+                    "GUILD_UPDATE": true,
+                    "CHANNEL_CREATE": true,
+                    "CHANNEL_UPDATE": true,
+                    "CHANNEL_DELETE": true,
+                    "CHANNEL_OVERWRITE_CREATE": true,
+                    "CHANNEL_OVERWRITE_UPDATE": true,
+                    "CHANNEL_OVERWRITE_DELETE": true,
+                    "MEMBER_KICK": true,
+                    "MEMBER_PRUNE": true,
+                    "MEMBER_BAN_ADD": true,
+                    "MEMBER_BAN_REMOVE": true,
+                    "MEMBER_UPDATE": true,
+                    "MEMBER_ROLE_UPDATE": true,
+                    "BOT_ADD	": true,
+                    "ROLE_CREATE": true,
+                    "ROLE_UPDATE": true,
+                    "ROLE_DELETE": true,
+                    "INVITE_CREATE": true,
+                    "INVITE_UPDATE	": true,
+                    "INVITE_DELETE	": true,
+                    "WEBHOOK_CREATE": true,
+                    "WEBHOOK_UPDATE": true,
+                    "WEBHOOK_DELETE": true,
+                    "EMOJI_CREATE": true,
+                    "EMOJI_UPDATE": true,
+                    "EMOJI_DELETE": true,
+                    "MESSAGE_DELETE": true,
+                    "MESSAGE_BULK_DELETE": true,
+                    "MESSAGE_PIN": true,
+                    "MESSAGE_UNPIN": true,
+                    "INTEGRATION_CREATE": true,
+                    "INTEGRATION_UPDATE": true,
+                    "INTEGRATION_DELETE": true,
+                    "STAGE_INSTANCE_CREATE": true,
+                    "STAGE_INSTANCE_UPDATE": true,
+                    "STAGE_INSTANCE_DELETE": true,
+                    "STICKER_CREATE": true,
+                    "STICKER_UPDATE": true,
+                    "STICKER_DELETE": true,
+                    "GUILD_SCHEDULED_EVENT_CREATE": true,
+                    "GUILD_SCHEDULED_EVENT_UPDATE": true,
+                    "GUILD_SCHEDULED_EVENT_DELETE": true,
+                    "THREAD_CREATE": true,
+                    "THREAD_UPDATE": true,
+                    "THREAD_DELETE": true,
+                    "APPLICATION_COMMAND_PERMISSION_UPDATE": true,
+                },
+            });
+
+        // Core Things //
+        this.config = options;
+        this.shoukaku = new ShoukakuHandler(this);
+        this.location = process.cwd();
+        this.spotify = new Spotify(options.spotify);
+        this.dbl = new dbl(options.dbl, this);
+        this.cluster = new Cluster.Client(this);
+        this.collectors = new CollectorManager();
+
+
+        // Command/Slash Manager //
+        this.commands = new CommandLoader(this);
+        this.commandManager = new CommandManager(this);
+        this.slashManager = new SlashManager(this);
+
+        // Listenners for events //
+        this.voiceHandler = new voiceService(this);
+        this.on("voiceChannelJoin", (member, newChannel) => this.voiceHandler.handle("join", member, newChannel));
+        this.on("voiceChannelLeave", (member, oldChannel) => this.voiceHandler.handle("leave", member, oldChannel));
+        this.on("voiceChannelSwitch", (member, newChannel, oldChannel) => this.voiceHandler.handle("switch", member, newChannel, oldChannel));
+
+        this.on("messageCreate", m => this.commandManager.handle(m));
+        this.on("interactionCreate", i => this.slashManager.handle(i))
+        this.on("error", (err) => {
+            if (err.toString().includes("Connection reset by peer")) return
+            console.log(err)
+        })
+
+        // Database //
+        this.database = new DatabaseManager(this);
+
+        // Shoukaku ( For music )
+        this.queue = new QueueManager(this);
+        // Events
+        this.events = new EventHandler(this);
+
+        if (this.cluster.maintenance) console.log("[Maitainance Mode] Cluster is in maitainance")
+
+        this.sweepers = new sweeperManager(this, {
+            sweep: ["client", "emojis", "guildCategories", "stickers", "useless", "guildMembers"],
+            timeout: 1000 * 60 * 60 * 10,
+            changeStatus: "*help | green-bot.app"
+        })
+    }
+    listenners(debug: boolean) {
+        const _list = debug ? ["multipleResolves", "uncaughtException", "uncaughtExceptionMonitor", "unhandledRejection", "warning"] : ["uncaughtException", "uncaughtExceptionMonitor", "unhandledRejection"];
+        _list.forEach((event) => {
+            process.on(event, new BaseError(event).handler)
+        })
+        return Promise;
+    }
+
+    hasBotPerm(context: Context | SlashContext, perm: any, channelVoice?: Eris.TextVoiceChannel) {
+        if (context.me.permissions.has("administrator")) return true;
+        const channel = channelVoice || context.channel;
+        let hasPerm = false;
+        if (perm === "voiceConnect" && !this.hasBotPerm(context, "viewChannel", channelVoice)) return false
+        const owerwrites = channel.permissionOverwrites.filter(ow => ow.id === this.user.id || context.me.roles.includes(ow.id))
+        if (!owerwrites.length && perm !== "viewChannel" && context.me.permissions.has(perm)) return true
+        if (!owerwrites.length && channel.permissionsOf(context.me).has(perm)) return true
+        owerwrites.forEach(owerwrite => {
+            if (hasPerm === true || hasPerm === false) return;
+            const data = owerwrite.json
+            if (data[perm] === undefined) return
+            if (data[perm] === true) return hasPerm = true;
+            if (data[perm] === false) return hasPerm = false;
+        })
+
+        if (!hasPerm && context.me.permissions.has(perm)) return true
+        if (!hasPerm && channel.permissionsOf(context.me).has(perm)) return true
+
+        return hasPerm;
+    }
+
+
+
+
+    async init() {
+        await this.connect();
+        await this.database.connect();
+    }
+}
+

module/src/BaseDiscordClient.ts

@@ -0,0 +1,28 @@
+import { Constants } from "eris";
+
+class Argument{
+    name:string;
+    required:boolean;
+    description: string;
+}
+
+class CommandCheck{
+    vote: boolean;
+    premium: boolean;
+    voice: boolean;
+    channel: boolean;
+    dispatcher: boolean;
+}
+
+export class BaseCommand {
+    name: string;
+    permissions: Array<string>;
+    description: string;
+    checks: CommandCheck;
+    aliases: Array<string>;
+    arguments: Array<Argument>;
+    run: Function;
+
+    constructor(commandData) {
+    }
+}

module/src/abstract/BaseCommand.ts

@@ -0,0 +1,14 @@
+const EventEmitter = require("events");
+export class BaseEvent extends EventEmitter {
+    once: boolean;
+    name: string
+    constructor(event) {
+     super();
+     this.name = event.name;
+     this.once = event.once;
+    }
+    exec(...e) {
+        this.run(...e).catch((e) => this.emit("error", e));
+    }
+}
+

module/src/abstract/BaseEvent.ts

@@ -0,0 +1,11 @@
+export class BaseError{
+    name: any;
+    constructor(name){
+        this.name = name;
+    }
+
+    handler(err){
+        console.log(err)
+        return console.log(`[${this.name || "Process<Unknownn>"}] ${err}`)
+    }
+}