Adds eslint and linted & improved routing for interactions

source/Discord/DiscordClient.ts

@@ -2,142 +2,66 @@ import {
     Client,
     GatewayIntentBits,
     Events,
-    Interaction,
-    ChatInputCommandInteraction,
-    MessageFlags,
-    Activity,
-    ActivityType, REST, inlineCode
+    ActivityType, REST
 } from "discord.js";
 import Commands from "./Commands/Commands";
 import {Container} from "../Container/Container";
 import {Logger} from "log4js";
-import {UserError} from "./UserError";
+import {InteractionRouter} from "./InteractionRouter";
 
 export class DiscordClient {
     private readonly client: Client;
-    private commands: Commands;
-    private readonly restClient: REST;
-    
-    public get Client (): Client {
+
+    public get Client(): Client {
         return this.client;
     }
-    
-    public get Commands(): Commands { 
-        return this.commands
+
+    public get Commands(): Commands {
+        return this.router.commands
     }
-    
+
     public get RESTClient(): REST {
         return this.restClient;
     }
-    
+
     public get ApplicationId(): string {
         return this.applicationId;
     }
-    
+
     constructor(
-      private readonly applicationId: string
+      private readonly applicationId: string,
+      private readonly router: InteractionRouter,
+      private readonly restClient: REST = new REST()
     ) {
         this.client = new Client({
             intents: [GatewayIntentBits.Guilds]
         })
-        
-        this.commands = new Commands();
-        this.restClient = new REST();
     }
-    
+
     applyEvents() {
         this.client.once(Events.ClientReady, () => {
+            if (!this.client.user) {
+                return;
+            }
+
             Container.get<Logger>("logger").info(`Ready! Logged in as ${this.client.user.tag}`);
             this.client.user.setActivity('your PnP playdates', {
                 type: ActivityType.Watching,
             });
         })
-        
+
         this.client.on(Events.GuildAvailable, () => {
             Container.get<Logger>("logger").info("Joined Guild?")
         })
-        
-        this.client.on(Events.InteractionCreate, async (interaction: Interaction) => {
-            const method = this.findCommandMethod(interaction);
-            if (!method) {
-                Container.get<Logger>("logger").error(`Could not find method for '${interaction.commandName}'`);
-                return;
-            }
-            
-            await method();
-        })
+
+        this.client.on(Events.InteractionCreate, this.router.route.bind(this.router));
     }
-    
+
     connect(token: string) {
         this.client.login(token);
     }
-    
+
     connectRESTClient(token: string) {
         this.restClient.setToken(token);
     }
-    
-    private findCommandMethod(interaction: Interaction) {
-        if (interaction.isChatInputCommand()) {
-            const command = this.commands.getCommand(interaction.commandName);
-            
-            if (!command) {
-                return null;
-            }
-            
-            if (!('execute' in command)) {
-                return null;
-            }
-            
-            return async () => {
-                Container.get<Logger>("logger").debug(`Found chat command ${interaction.commandName}: running...`);
-                
-                try {
-                    await command.execute(interaction)
-                }
-                catch (e: any) {
-                    Container.get<Logger>("logger").error(e)
-                    
-                    let userMessage = ":x: There was an error while executing this command!";
-                    if (e.constructor.name === UserError.name) {
-                        userMessage = `:x: \`${e.message}\` - Please validate your request!`
-                        if (e.tryInstead) {
-                            userMessage += `
-
-You can try the following:
-${inlineCode(e.tryInstead)}`
-                        }
-                    }
-                    if (interaction.replied || interaction.deferred) {
-                        await interaction.followUp({ content: userMessage, flags: MessageFlags.Ephemeral });
-                    } else {
-                        await interaction.reply({ content: userMessage, flags: MessageFlags.Ephemeral });
-                    }
-                }
-            }
-        }
-        
-        if (interaction.isAutocomplete()) {
-            const command = this.commands.getCommand(interaction.commandName);
-
-            if (!command) {
-                return null;
-            }
-
-            if (!('handleAutocomplete' in command)) {
-                return null;
-            }
-            
-            return async () => {
-                Container.get<Logger>("logger").debug(`Found command ${interaction.commandName} for autocomplete: handling...`);
-                
-                try {
-                    await command.handleAutocomplete(interaction);
-                } catch (e: any) {
-                    Container.get<Logger>('logger').error(e);
-                }
-            }
-        }
-        
-        return null;
-    }
 }