Fix linting issues

Merge branch 'develop' into feature/113-give-command
Update dependency typeorm to v0.3.19 (#136 )
2024-01-11 18:11:15 +00:00 · 2024-01-11 18:10:32 +00:00 · 2024-01-08 13:43:50 +00:00 · 2024-01-08 13:43:01 +00:00 · 2024-01-08 13:40:37 +00:00 · 2024-01-05 19:26:44 +00:00
45 changed files with 1627 additions and 363 deletions
--- a/.drone.yml
+++ b/.drone.yml
@ -93,6 +93,12 @@ steps:
  commands:
  - npm ci
  - npm run build
 - name: lint
  image: node
  commands:
  - npm run lint
 - name: test
  image: node
  commands:
--- a/.eslintrc.json
+++ b/.eslintrc.json
@ -0,0 +1,45 @@
 {
    "env": {
        "browser": true,
        "es2021": true
    },
    "extends": [
        "eslint:recommended",
        "plugin:@typescript-eslint/recommended"
    ],
    "parser": "@typescript-eslint/parser",
    "parserOptions": {
        "ecmaVersion": "latest",
        "sourceType": "module"
    },
    "plugins": [
        "@typescript-eslint"
    ],
    "rules": {
        "indent": [
            "error",
            4
        ],
        "linebreak-style": [
            "error",
            "unix"
        ],
        "quotes": [
            "error",
            "double"
        ],
        "semi": [
            "error",
            "always"
        ]
    },
    "globals": {
        "jest": true,
        "require": true,
        "exports": true,
        "process": true
    },
    "ignorePatterns": [
        "dist/**/*"
    ]
 }
--- a/package-lock.json
+++ b/package-lock.json
--- a/package.json
+++ b/package.json
@ -8,6 +8,8 @@
    "build": "tsc",
    "start": "node ./dist/bot.js",
    "test": "jest --passWithNoTests",
    "lint": "eslint .",
    "lint:fix": "eslint . --fix",
    "db:up": "typeorm migration:run -d dist/database/dataSources/appDataSource.js",
    "db:down": "typeorm migration:revert -d dist/database/dataSources/appDataSource.js",
    "db:create": "typeorm migration:create ./src/database/migrations/app/new",
@ -37,12 +39,15 @@
    "minimatch": "9.0.3",
    "mysql": "^2.18.1",
    "ts-jest": "^29.0.0",
-    "typeorm": "0.3.17"
+    "typeorm": "0.3.19"
  },
  "resolutions": {
  },
  "devDependencies": {
    "@types/node": "^20.0.0",
    "@typescript-eslint/eslint-plugin": "^6.16.0",
    "@typescript-eslint/parser": "^6.16.0",
    "eslint": "^8.56.0",
    "np": "^9.0.0",
    "typescript": "^5.0.0"
  }
--- a/src/Functions/CardMetadataFunction.ts
+++ b/src/Functions/CardMetadataFunction.ts
@ -2,12 +2,12 @@ import { readFileSync } from "fs";
 import path from "path";
 import Config from "../database/entities/app/Config";
 import { glob } from "glob";
-import SeriesMetadata from "../contracts/SeriesMetadata";
+import { SeriesMetadata } from "../contracts/SeriesMetadata";
 import { CoreClient } from "../client/client";
 export default class CardMetadataFunction {
    public static async Execute(overrideSafeMode: boolean = false): Promise<boolean> {
-        if (!overrideSafeMode && await Config.GetValue('safemode') == "true") return false;
+        if (!overrideSafeMode && await Config.GetValue("safemode") == "true") return false;
        try {
            CoreClient.Cards = await this.FindMetadataJSONs();
@ -16,7 +16,7 @@ export default class CardMetadataFunction {
        } catch (e) {
            console.error(e);
-            await Config.SetValue('safemode', 'true');
+            await Config.SetValue("safemode", "true");
            return false;
        }
@ -26,9 +26,9 @@ export default class CardMetadataFunction {
    private static async FindMetadataJSONs(): Promise<SeriesMetadata[]> {
        const res: SeriesMetadata[] = [];
-        const seriesJSONs = await glob(path.join(process.env.DATA_DIR!, 'cards', '/**/*.json'));
+        const seriesJSONs = await glob(path.join(process.env.DATA_DIR!, "cards", "/**/*.json"));
-        for (let jsonPath of seriesJSONs) {
+        for (const jsonPath of seriesJSONs) {
            console.log(`Reading file ${jsonPath}`);
            const jsonFile = readFileSync(jsonPath);
            const parsedJson: SeriesMetadata[] = JSON.parse(jsonFile.toString());
--- a/src/bot.ts
+++ b/src/bot.ts
@ -23,7 +23,7 @@ const requiredConfigs: string[] = [
    "DB_SYNC",
    "DB_LOGGING",
    "EXPRESS_PORT",
-]
+];
 requiredConfigs.forEach(config => {
    if (!process.env[config]) {
@ -40,7 +40,7 @@ Registry.RegisterCommands();
 Registry.RegisterEvents();
 Registry.RegisterButtonEvents();
-if (!existsSync(`${process.env.DATA_DIR}/cards`) && process.env.GDRIVESYNC_AUTO && process.env.GDRIVESYNC_AUTO == 'true') {
+if (!existsSync(`${process.env.DATA_DIR}/cards`) && process.env.GDRIVESYNC_AUTO && process.env.GDRIVESYNC_AUTO == "true") {
    console.log("Card directory not found, syncing...");
    CoreClient.AllowDrops = false;
@ -50,7 +50,7 @@ if (!existsSync(`${process.env.DATA_DIR}/cards`) && process.env.GDRIVESYNC_AUTO
            console.error(error.code);
            throw `Error while running sync command. Code: ${error.code}`;
        } else {
-            console.log('Synced successfully.');
+            console.log("Synced successfully.");
            CoreClient.AllowDrops = true;
        }
    });
--- a/src/buttonEvents/Claim.ts
+++ b/src/buttonEvents/Claim.ts
@ -8,20 +8,20 @@ export default class Claim extends ButtonEvent {
    public override async execute(interaction: ButtonInteraction) {
        if (!interaction.guild || !interaction.guildId) return;
-        const cardNumber = interaction.customId.split(' ')[1];
+        const cardNumber = interaction.customId.split(" ")[1];
-        const claimId = interaction.customId.split(' ')[2];
+        const claimId = interaction.customId.split(" ")[2];
-        const droppedBy = interaction.customId.split(' ')[3];
+        const droppedBy = interaction.customId.split(" ")[3];
        const userId = interaction.user.id;
        const claimed = await eClaim.FetchOneByClaimId(claimId);
        if (claimed) {
-            await interaction.reply('This card has already been claimed');
+            await interaction.reply("This card has already been claimed");
            return;
        }
        if (claimId == CoreClient.ClaimId && userId != droppedBy) {
-            await interaction.reply('The latest dropped card can only be claimed by the user who dropped it');
+            await interaction.reply("The latest dropped card can only be claimed by the user who dropped it");
            return;
        }
--- a/src/buttonEvents/Inventory.ts
+++ b/src/buttonEvents/Inventory.ts
@ -4,8 +4,8 @@ import InventoryHelper from "../helpers/InventoryHelper";
 export default class Inventory extends ButtonEvent {
    public override async execute(interaction: ButtonInteraction) {
-        const userid = interaction.customId.split(' ')[1];
+        const userid = interaction.customId.split(" ")[1];
-        const page = interaction.customId.split(' ')[2];
+        const page = interaction.customId.split(" ")[2];
        try {
            const embed = await InventoryHelper.GenerateInventoryPage(interaction.user.username, userid, Number(page));
--- a/src/buttonEvents/Reroll.ts
+++ b/src/buttonEvents/Reroll.ts
@ -1,4 +1,4 @@
-import { AttachmentBuilder, ButtonInteraction, DiscordAPIError } from "discord.js";
+import { AttachmentBuilder, ButtonInteraction } from "discord.js";
 import { ButtonEvent } from "../type/buttonEvent";
 import { readFileSync } from "fs";
 import { v4 } from "uuid";
@ -11,28 +11,26 @@ import path from "path";
 export default class Reroll extends ButtonEvent {
    public override async execute(interaction: ButtonInteraction) {
        if (!CoreClient.AllowDrops) {
-            await interaction.reply('Bot is currently syncing, please wait until its done.');
+            await interaction.reply("Bot is currently syncing, please wait until its done.");
            return;
        }
-        if (await Config.GetValue('safemode') == "true") {
+        if (await Config.GetValue("safemode") == "true") {
-            await interaction.reply('Safe Mode has been activated, please resync to continue.');
+            await interaction.reply("Safe Mode has been activated, please resync to continue.");
            return;
        }
        const randomCard = CardDropHelperMetadata.GetRandomCard();
        if (!randomCard) {
-            await interaction.reply('Unable to fetch card, please try again.');
+            await interaction.reply("Unable to fetch card, please try again.");
            return;
        }
        try {
-            let image: Buffer;
+            const image = readFileSync(path.join(process.env.DATA_DIR!, "cards", randomCard.card.path));
            const imageFileName = randomCard.card.path.split("/").pop()!;
            image = readFileSync(path.join(process.env.DATA_DIR!, 'cards', randomCard.card.path));
            await interaction.deferReply();
            const attachment = new AttachmentBuilder(image, { name: imageFileName });
--- a/src/client/client.ts
+++ b/src/client/client.ts
@ -1,24 +1,22 @@
-import { Client } from "discord.js";
+import { Client, DMChannel, Guild, GuildBan, GuildMember, Message, NonThreadGuildBasedChannel, PartialGuildMember, PartialMessage } from "discord.js";
 import * as dotenv from "dotenv";
 import { EventType } from "../constants/EventType";
 import ICommandItem from "../contracts/ICommandItem";
-import IEventItem from "../contracts/IEventItem";
+import EventExecutors from "../contracts/EventExecutors";
 import { Command } from "../type/command";
 import { Events } from "./events";
 import { Util } from "./util";
-import IButtonEventItem from "../contracts/IButtonEventItem";
+import IButtonEventItem from "../contracts/ButtonEventItem";
 import { ButtonEvent } from "../type/buttonEvent";
 import AppDataSource from "../database/dataSources/appDataSource";
 import { Environment } from "../constants/Environment";
 import Webhooks from "../webhooks";
 import CardMetadataFunction from "../Functions/CardMetadataFunction";
-import SeriesMetadata from "../contracts/SeriesMetadata";
+import { SeriesMetadata } from "../contracts/SeriesMetadata";
 import InventoryHelper from "../helpers/InventoryHelper";
 export class CoreClient extends Client {
    private static _commandItems: ICommandItem[];
-    private static _eventItems: IEventItem[];
+    private static _eventExecutors: EventExecutors;
    private static _buttonEvents: IButtonEventItem[];
    private _events: Events;
@ -34,8 +32,8 @@ export class CoreClient extends Client {
        return this._commandItems;
    }
-    public static get eventItems(): IEventItem[] {
+    public static get eventExecutors(): EventExecutors {
-        return this._eventItems;
+        return this._eventExecutors;
    }
    public static get buttonEvents(): IButtonEventItem[] {
@ -47,7 +45,6 @@ export class CoreClient extends Client {
        dotenv.config();
        CoreClient._commandItems = [];
        CoreClient._eventItems = [];
        CoreClient._buttonEvents = [];
        this._events = new Events();
@ -75,15 +72,11 @@ export class CoreClient extends Client {
        await CardMetadataFunction.Execute(true);
-        this._util.loadEvents(this, CoreClient._eventItems);
+        this._util.loadEvents(this, CoreClient._eventExecutors);
        this._util.loadSlashCommands(this);
        this._webhooks.start();
        console.log(`Registered Commands: ${CoreClient._commandItems.flatMap(x => x.Name).join(", ")}`);
        console.log(`Registered Events: ${CoreClient._eventItems.flatMap(x => x.EventType).join(", ")}`);
        console.log(`Registered Buttons: ${CoreClient._buttonEvents.flatMap(x => x.ButtonId).join(", ")}`);
        await super.login(process.env.BOT_TOKEN);
    }
@ -95,20 +88,260 @@ export class CoreClient extends Client {
            ServerId: serverId,
        };
-        if (environment &= CoreClient.Environment) {
+        if ((environment & CoreClient.Environment) == CoreClient.Environment) {
            CoreClient._commandItems.push(item);
        }
    }
-    public static RegisterEvent(eventType: EventType, func: Function, environment: Environment = Environment.All) {
+    public static RegisterChannelCreateEvent(fn: (channel: NonThreadGuildBasedChannel) => void) {
-        const item: IEventItem = {
+        if (this._eventExecutors) {
-            EventType: eventType,
+            this._eventExecutors.ChannelCreate.push(fn);
-            ExecutionFunction: func,
+        } else {
-            Environment: environment,
+            this._eventExecutors = {
                ChannelCreate: [ fn ],
                ChannelDelete: [],
                ChannelUpdate: [],
                GuildBanAdd: [],
                GuildBanRemove: [],
                GuildCreate: [],
                GuildMemberAdd: [],
                GuildMemberRemove: [],
                GuildMemebrUpdate: [],
                MessageCreate: [],
                MessageDelete: [],
                MessageUpdate: [],
            };
        }
    }
-        if (environment &= CoreClient.Environment) {
+    public static RegisterChannelDeleteEvent(fn: (channel: DMChannel | NonThreadGuildBasedChannel) => void) {
-            CoreClient._eventItems.push(item);
+        if (this._eventExecutors) {
            this._eventExecutors.ChannelDelete.push(fn);
        } else {
            this._eventExecutors = {
                ChannelCreate: [],
                ChannelDelete: [ fn ],
                ChannelUpdate: [],
                GuildBanAdd: [],
                GuildBanRemove: [],
                GuildCreate: [],
                GuildMemberAdd: [],
                GuildMemberRemove: [],
                GuildMemebrUpdate: [],
                MessageCreate: [],
                MessageDelete: [],
                MessageUpdate: [],
            };
        }
    }
    public static RegisterChannelUpdateEvent(fn: (channel: DMChannel | NonThreadGuildBasedChannel) => void) {
        if (this._eventExecutors) {
            this._eventExecutors.ChannelCreate.push(fn);
        } else {
            this._eventExecutors = {
                ChannelCreate: [],
                ChannelDelete: [],
                ChannelUpdate: [ fn ],
                GuildBanAdd: [],
                GuildBanRemove: [],
                GuildCreate: [],
                GuildMemberAdd: [],
                GuildMemberRemove: [],
                GuildMemebrUpdate: [],
                MessageCreate: [],
                MessageDelete: [],
                MessageUpdate: [],
            };
        }
    }
    public static RegisterGuildBanAddEvent(fn: (ban: GuildBan) => void) {
        if (this._eventExecutors) {
            this._eventExecutors.GuildBanAdd.push(fn);
        } else {
            this._eventExecutors = {
                ChannelCreate: [],
                ChannelDelete: [],
                ChannelUpdate: [],
                GuildBanAdd: [ fn ],
                GuildBanRemove: [],
                GuildCreate: [],
                GuildMemberAdd: [],
                GuildMemberRemove: [],
                GuildMemebrUpdate: [],
                MessageCreate: [],
                MessageDelete: [],
                MessageUpdate: [],
            };
        }
    }
    public static RegisterGuildBanRemoveEvent(fn: (channel: GuildBan) => void) {
        if (this._eventExecutors) {
            this._eventExecutors.GuildBanRemove.push(fn);
        } else {
            this._eventExecutors = {
                ChannelCreate: [],
                ChannelDelete: [],
                ChannelUpdate: [],
                GuildBanAdd: [],
                GuildBanRemove: [ fn ],
                GuildCreate: [],
                GuildMemberAdd: [],
                GuildMemberRemove: [],
                GuildMemebrUpdate: [],
                MessageCreate: [],
                MessageDelete: [],
                MessageUpdate: [],
            };
        }
    }
    public static RegisterGuildCreateEvent(fn: (guild: Guild) => void) {
        if (this._eventExecutors) {
            this._eventExecutors.GuildCreate.push(fn);
        } else {
            this._eventExecutors = {
                ChannelCreate: [],
                ChannelDelete: [],
                ChannelUpdate: [],
                GuildBanAdd: [],
                GuildBanRemove: [],
                GuildCreate: [ fn ],
                GuildMemberAdd: [],
                GuildMemberRemove: [],
                GuildMemebrUpdate: [],
                MessageCreate: [],
                MessageDelete: [],
                MessageUpdate: [],
            };
        }
    }
    public static RegisterGuildMemberAddEvent(fn: (member: GuildMember) => void) {
        if (this._eventExecutors) {
            this._eventExecutors.GuildMemberAdd.push(fn);
        } else {
            this._eventExecutors = {
                ChannelCreate: [],
                ChannelDelete: [],
                ChannelUpdate: [],
                GuildBanAdd: [],
                GuildBanRemove: [],
                GuildCreate: [],
                GuildMemberAdd: [ fn ],
                GuildMemberRemove: [],
                GuildMemebrUpdate: [],
                MessageCreate: [],
                MessageDelete: [],
                MessageUpdate: [],
            };
        }
    }
    public static RegisterGuildMemberRemoveEvent(fn: (member: GuildMember | PartialGuildMember) => void) {
        if (this._eventExecutors) {
            this._eventExecutors.GuildMemberRemove.push(fn);
        } else {
            this._eventExecutors = {
                ChannelCreate: [],
                ChannelDelete: [],
                ChannelUpdate: [],
                GuildBanAdd: [],
                GuildBanRemove: [],
                GuildCreate: [],
                GuildMemberAdd: [],
                GuildMemberRemove: [ fn ],
                GuildMemebrUpdate: [],
                MessageCreate: [],
                MessageDelete: [],
                MessageUpdate: [],
            };
        }
    }
    public static GuildMemebrUpdate(fn: (oldMember: GuildMember | PartialGuildMember, newMember: GuildMember) => void) {
        if (this._eventExecutors) {
            this._eventExecutors.GuildMemebrUpdate.push(fn);
        } else {
            this._eventExecutors = {
                ChannelCreate: [],
                ChannelDelete: [],
                ChannelUpdate: [],
                GuildBanAdd: [],
                GuildBanRemove: [],
                GuildCreate: [],
                GuildMemberAdd: [],
                GuildMemberRemove: [],
                GuildMemebrUpdate: [ fn ],
                MessageCreate: [],
                MessageDelete: [],
                MessageUpdate: [],
            };
        }
    }
    public static RegisterMessageCreateEvent(fn: (message: Message<boolean>) => void) {
        if (this._eventExecutors) {
            this._eventExecutors.MessageCreate.push(fn);
        } else {
            this._eventExecutors = {
                ChannelCreate: [],
                ChannelDelete: [],
                ChannelUpdate: [],
                GuildBanAdd: [],
                GuildBanRemove: [],
                GuildCreate: [],
                GuildMemberAdd: [],
                GuildMemberRemove: [],
                GuildMemebrUpdate: [],
                MessageCreate: [ fn ],
                MessageDelete: [],
                MessageUpdate: [],
            };
        }
    }
    public static RegisterMessageDeleteEvent(fn: (message: Message<boolean> | PartialMessage) => void) {
        if (this._eventExecutors) {
            this._eventExecutors.MessageDelete.push(fn);
        } else {
            this._eventExecutors = {
                ChannelCreate: [],
                ChannelDelete: [],
                ChannelUpdate: [],
                GuildBanAdd: [],
                GuildBanRemove: [],
                GuildCreate: [],
                GuildMemberAdd: [],
                GuildMemberRemove: [],
                GuildMemebrUpdate: [],
                MessageCreate: [],
                MessageDelete: [ fn ],
                MessageUpdate: [],
            };
        }
    }
    public static RegisterMessageUpdateEvent(fn: (oldMessage: Message<boolean> | PartialMessage, newMessage: Message<boolean> | PartialMessage) => void) {
        if (this._eventExecutors) {
            this._eventExecutors.MessageUpdate.push(fn);
        } else {
            this._eventExecutors = {
                ChannelCreate: [],
                ChannelDelete: [],
                ChannelUpdate: [],
                GuildBanAdd: [],
                GuildBanRemove: [],
                GuildCreate: [],
                GuildMemberAdd: [],
                GuildMemberRemove: [],
                GuildMemebrUpdate: [],
                MessageCreate: [],
                MessageDelete: [],
                MessageUpdate: [ fn ],
            };
        }
    }
@ -119,7 +352,7 @@ export class CoreClient extends Client {
            Environment: environment,
        };
-        if (environment &= CoreClient.Environment) {
+        if ((environment & CoreClient.Environment) == CoreClient.Environment) {
            CoreClient._buttonEvents.push(item);
        }
    }
--- a/src/client/interactionCreate/Button.ts
+++ b/src/client/interactionCreate/Button.ts
@ -1,14 +1,14 @@
-import { ButtonInteraction, Interaction } from "discord.js";
+import { ButtonInteraction } from "discord.js";
 import { CoreClient } from "../client";
 export default class Button {
    public static async onButtonClicked(interaction: ButtonInteraction) {
        if (!interaction.isButton) return;
-        const item = CoreClient.buttonEvents.find(x => x.ButtonId == interaction.customId.split(' ')[0]);
+        const item = CoreClient.buttonEvents.find(x => x.ButtonId == interaction.customId.split(" ")[0]);
        if (!item) {
-            await interaction.reply('Event not found');
+            await interaction.reply("Event not found");
            return;
        }
--- a/src/client/interactionCreate/ChatInputCommand.ts
+++ b/src/client/interactionCreate/ChatInputCommand.ts
@ -13,7 +13,7 @@ export default class ChatInputCommand {
        if (!itemForServer) {
            if (!item) {
-                await interaction.reply('Command not found');
+                await interaction.reply("Command not found");
                return;
            }
--- a/src/client/util.ts
+++ b/src/client/util.ts
@ -1,6 +1,5 @@
 import { Client, REST, Routes, SlashCommandBuilder } from "discord.js";
-import { EventType } from "../constants/EventType";
+import EventExecutors from "../contracts/EventExecutors";
 import IEventItem from "../contracts/IEventItem";
 import { CoreClient } from "./client";
 export class Util {
@ -10,25 +9,25 @@ export class Util {
        const globalCommands = registeredCommands.filter(x => !x.ServerId);
        const guildCommands = registeredCommands.filter(x => x.ServerId);
-        const globalCommandData: SlashCommandBuilder[] = [];
+        const globalCommandData: Omit<SlashCommandBuilder, "addSubcommand" | "addSubcommandGroup">[] = [];
-        for (let command of globalCommands) {
+        for (const command of globalCommands) {
            if (!command.Command.CommandBuilder) continue;
-            if (command.Environment &= CoreClient.Environment) {
+            if ((command.Environment & CoreClient.Environment) == CoreClient.Environment) {
                globalCommandData.push(command.Command.CommandBuilder);
            }
        }
        const guildIds: string[] = [];
-        for (let command of guildCommands) {
+        for (const command of guildCommands) {
            if (!guildIds.find(x => x == command.ServerId)) {
                guildIds.push(command.ServerId!);
            }
        }
-        const rest = new REST({ version: '10' }).setToken(process.env.BOT_TOKEN!);
+        const rest = new REST({ version: "10" }).setToken(process.env.BOT_TOKEN!);
        rest.put(
            Routes.applicationCommands(process.env.BOT_CLIENTID!),
@ -37,13 +36,13 @@ export class Util {
            }
        );
-        for (let guild of guildIds) {
+        for (const guild of guildIds) {
-            const guildCommandData: SlashCommandBuilder[] = [];
+            const guildCommandData: Omit<SlashCommandBuilder, "addSubcommand" | "addSubcommandGroup">[] = [];
-            for (let command of guildCommands.filter(x => x.ServerId == guild)) {
+            for (const command of guildCommands.filter(x => x.ServerId == guild)) {
                if (!command.Command.CommandBuilder) continue;
-                if (command.Environment &= CoreClient.Environment) {
+                if ((command.Environment & CoreClient.Environment) == CoreClient.Environment) {
                    guildCommandData.push(command.Command.CommandBuilder);
                }
            }
@ -55,53 +54,23 @@ export class Util {
                {
                    body: guildCommandData
                }
-            )
+            );
        }
    }
    // Load the events
-    loadEvents(client: Client, events: IEventItem[]) {
+    loadEvents(client: Client, events: EventExecutors) {
-        events.forEach((e) => {
+        client.on("channelCreate", (channel) => events.ChannelCreate.forEach((fn) => fn(channel)));
-            switch(e.EventType) {
+        client.on("channelDelete", (channel) => events.ChannelDelete.forEach((fn) => fn(channel)));
-                case EventType.ChannelCreate:
+        client.on("channelUpdate", (channel) => events.ChannelUpdate.forEach((fn) => fn(channel)));
-                    client.on('channelCreate', (channel) => e.ExecutionFunction(channel));
+        client.on("guildBanAdd", (ban) => events.GuildBanAdd.forEach((fn) => fn(ban)));
-                    break;
+        client.on("guildBanRemove", (ban) => events.GuildBanRemove.forEach((fn) => fn(ban)));
-                case EventType.ChannelDelete:
+        client.on("guildCreate", (guild) => events.GuildCreate.forEach((fn) => fn(guild)));
-                    client.on('channelDelete', (channel) => e.ExecutionFunction(channel));
+        client.on("guildMemberAdd", (member) => events.GuildMemberAdd.forEach((fn) => fn(member)));
-                    break;
+        client.on("guildMemberRemove", (member) => events.GuildMemberRemove.forEach((fn) => fn(member)));
-                case EventType.ChannelUpdate:
+        client.on("guildMemberUpdate", (oldMember, newMember) => events.GuildMemebrUpdate.forEach((fn) => fn(oldMember, newMember)));
-                    client.on('channelUpdate', (channel) => e.ExecutionFunction(channel));
+        client.on("messageCreate", (message) => events.MessageCreate.forEach((fn) => fn(message)));
-                    break;
+        client.on("messageDelete", (message) => events.MessageDelete.forEach((fn) => fn(message)));
-                case EventType.GuildBanAdd:
+        client.on("messageUpdate", (oldMessage, newMessage) => events.MessageUpdate.forEach((fn) => fn(oldMessage, newMessage)));
                    client.on('guildBanAdd', (ban) => e.ExecutionFunction(ban));
                    break;
                case EventType.GuildBanRemove:
                    client.on('guildBanRemove', (ban) => e.ExecutionFunction(ban));
                    break;
                case EventType.GuildCreate:
                    client.on('guildCreate', (guild) => e.ExecutionFunction(guild));
                    break;
                case EventType.GuildMemberAdd:
                    client.on('guildMemberAdd', (member) => e.ExecutionFunction(member));
                    break;
                case EventType.GuildMemberRemove:
                    client.on('guildMemberRemove', (member) => e.ExecutionFunction(member));
                    break;
                case EventType.GuildMemberUpdate:
                    client.on('guildMemberUpdate', (oldMember, newMember) => e.ExecutionFunction(oldMember, newMember));
                    break;
                case EventType.MessageCreate:
                    client.on('messageCreate', (message) => e.ExecutionFunction(message));
                    break;
                case EventType.MessageDelete:
                    client.on('messageDelete', (message) => e.ExecutionFunction(message));
                    break;
                case EventType.MessageUpdate:
                    client.on('messageUpdate', (oldMessage, newMessage) => e.ExecutionFunction(oldMessage, newMessage));
                    break;
                default:
                    console.error('Event not implemented.');
            }
        });
    }
 }
--- a/src/commands/about.ts
+++ b/src/commands/about.ts
@ -6,9 +6,9 @@ export default class About extends Command {
    constructor() {
        super();
-        super.CommandBuilder = new SlashCommandBuilder()
+        this.CommandBuilder = new SlashCommandBuilder()
-            .setName('about')
+            .setName("about")
-            .setDescription('About Bot');
+            .setDescription("About Bot");
    }
    public override async execute(interaction: CommandInteraction) {
--- a/src/commands/drop.ts
+++ b/src/commands/drop.ts
@ -12,35 +12,33 @@ export default class Drop extends Command {
    constructor() {
        super();
-        super.CommandBuilder = new SlashCommandBuilder()
+        this.CommandBuilder = new SlashCommandBuilder()
-            .setName('drop')
+            .setName("drop")
-            .setDescription('Summon a new card drop');
+            .setDescription("Summon a new card drop");
    }
    public override async execute(interaction: CommandInteraction) {
        if (!CoreClient.AllowDrops) {
-            await interaction.reply('Bot is currently syncing, please wait until its done.');
+            await interaction.reply("Bot is currently syncing, please wait until its done.");
            return;
        }
-        if (await Config.GetValue('safemode') == "true") {
+        if (await Config.GetValue("safemode") == "true") {
-            await interaction.reply('Safe Mode has been activated, please resync to continue.');
+            await interaction.reply("Safe Mode has been activated, please resync to continue.");
            return;
        }
        const randomCard = CardDropHelperMetadata.GetRandomCard();
        if (!randomCard) {
-            await interaction.reply('Unable to fetch card, please try again.');
+            await interaction.reply("Unable to fetch card, please try again.");
            return;
        }
        try {
-            let image: Buffer;
+            const image = readFileSync(path.join(process.env.DATA_DIR!, "cards", randomCard.card.path));
            const imageFileName = randomCard.card.path.split("/").pop()!;
            image = readFileSync(path.join(process.env.DATA_DIR!, 'cards', randomCard.card.path));
            await interaction.deferReply();
            const attachment = new AttachmentBuilder(image, { name: imageFileName });
--- a/src/commands/gdrivesync.ts
+++ b/src/commands/gdrivesync.ts
@ -9,37 +9,37 @@ export default class Gdrivesync extends Command {
    constructor() {
        super();
-        super.CommandBuilder = new SlashCommandBuilder()
+        this.CommandBuilder = new SlashCommandBuilder()
-            .setName('gdrivesync')
+            .setName("gdrivesync")
-            .setDescription('Sync google drive to the bot')
+            .setDescription("Sync google drive to the bot")
            .setDefaultMemberPermissions(PermissionsBitField.Flags.Administrator);
    }
    public override async execute(interaction: CommandInteraction<CacheType>) {
        if (!interaction.isChatInputCommand()) return;
-        const whitelistedUsers = process.env.BOT_ADMINS!.split(',');
+        const whitelistedUsers = process.env.BOT_ADMINS!.split(",");
        if (!whitelistedUsers.find(x => x == interaction.user.id)) {
            await interaction.reply("Only whitelisted users can use this command.");
            return;
        }
-        await interaction.reply('Syncing, this might take a while...');
+        await interaction.reply("Syncing, this might take a while...");
        CoreClient.AllowDrops = false;
        exec(`rclone sync card-drop-gdrive: ${process.env.DATA_DIR}/cards`, async (error: ExecException | null) => {
            if (error) {
                await interaction.editReply(`Error while running sync command. Safe Mode has been activated. Code: ${error.code}`);
-                await Config.SetValue('safemode', 'true');
+                await Config.SetValue("safemode", "true");
            } else {
                await CardMetadataFunction.Execute();
-                await interaction.editReply('Synced successfully.');
+                await interaction.editReply("Synced successfully.");
                CoreClient.AllowDrops = true;
-                await Config.SetValue('safemode', 'false');
+                await Config.SetValue("safemode", "false");
            }
        });
    }
--- a/src/commands/give.ts
+++ b/src/commands/give.ts
@ -10,41 +10,41 @@ export default class Give extends Command {
        super();
        this.CommandBuilder = new SlashCommandBuilder()
-            .setName('give')
+            .setName("give")
-            .setDescription('Give a user a card manually, in case bot breaks')
+            .setDescription("Give a user a card manually, in case bot breaks")
            .setDefaultMemberPermissions(PermissionsBitField.Flags.Administrator)
            .addStringOption(x =>
                x
-                    .setName('cardnumber')
+                    .setName("cardnumber")
-                    .setDescription('G')
+                    .setDescription("G")
                    .setRequired(true))
            .addUserOption(x =>
                x
-                    .setName('user')
+                    .setName("user")
                    .setDescription("The user to give the card to")
                    .setRequired(true));
    }
    public override async execute(interaction: CommandInteraction<CacheType>) {
        if (!CoreClient.AllowDrops) {
-            await interaction.reply('Bot is currently syncing, please wait until its done.');
+            await interaction.reply("Bot is currently syncing, please wait until its done.");
            return;
        }
-        if (await Config.GetValue('safemode') == "true") {
+        if (await Config.GetValue("safemode") == "true") {
-            await interaction.reply('Safe Mode has been activated, please resync to continue.');
+            await interaction.reply("Safe Mode has been activated, please resync to continue.");
            return;
        }
-        const whitelistedUsers = process.env.BOT_ADMINS!.split(',');
+        const whitelistedUsers = process.env.BOT_ADMINS!.split(",");
        if (!whitelistedUsers.find(x => x == interaction.user.id)) {
            await interaction.reply("Only whitelisted users can use this command.");
            return;
        }
-        const cardNumber = interaction.options.get('cardnumber', true);
+        const cardNumber = interaction.options.get("cardnumber", true);
-        const user = interaction.options.getUser('user', true);
+        const user = interaction.options.getUser("user", true);
        const card = CardDropHelperMetadata.GetCardByCardNumber(cardNumber.value!.toString());
--- a/src/commands/inventory.ts
+++ b/src/commands/inventory.ts
@ -7,16 +7,16 @@ export default class Inventory extends Command {
        super();
        this.CommandBuilder = new SlashCommandBuilder()
-            .setName('inventory')
+            .setName("inventory")
-            .setDescription('View your inventory')
+            .setDescription("View your inventory")
            .addNumberOption(x =>
                x
-                    .setName('page')
+                    .setName("page")
-                    .setDescription('The page to start with'));
+                    .setDescription("The page to start with"));
    }
    public override async execute(interaction: CommandInteraction) {
-        const page = interaction.options.get('page');
+        const page = interaction.options.get("page");
        try {
            let pageNumber = 0;
--- a/src/commands/resync.ts
+++ b/src/commands/resync.ts
@ -7,27 +7,27 @@ export default class Resync extends Command {
    constructor() {
        super();
-        super.CommandBuilder = new SlashCommandBuilder()
+        this.CommandBuilder = new SlashCommandBuilder()
-            .setName('resync')
+            .setName("resync")
-            .setDescription('Resync the card database')
+            .setDescription("Resync the card database")
            .setDefaultMemberPermissions(PermissionsBitField.Flags.Administrator);
    }
    public override async execute(interaction: CommandInteraction<CacheType>) {
        if (!interaction.isChatInputCommand()) return;
-        const whitelistedUsers = process.env.BOT_ADMINS!.split(',');
+        const whitelistedUsers = process.env.BOT_ADMINS!.split(",");
        if (!whitelistedUsers.find(x => x == interaction.user.id)) {
            await interaction.reply("Only whitelisted users can use this command.");
            return;
        }
-        let result = await CardMetadataFunction.Execute(true);
+        const result = await CardMetadataFunction.Execute(true);
        if (result) {
-            if (await Config.GetValue('safemode') == "true") {
+            if (await Config.GetValue("safemode") == "true") {
-                await Config.SetValue('safemode', 'false');
+                await Config.SetValue("safemode", "false");
                await interaction.reply("Resynced database and disabled safe mode.");
                return;
--- a/src/commands/stage/dropnumber.ts
+++ b/src/commands/stage/dropnumber.ts
@ -11,23 +11,23 @@ export default class Dropnumber extends Command {
    constructor() {
        super();
-        super.CommandBuilder = new SlashCommandBuilder()
+        this.CommandBuilder = new SlashCommandBuilder()
-            .setName('dropnumber')
+            .setName("dropnumber")
-            .setDescription('(TEST) Summon a specific card')
+            .setDescription("(TEST) Summon a specific card")
            .addStringOption(x =>
                x
-                    .setName('cardnumber')
+                    .setName("cardnumber")
-                    .setDescription('The card number to summon')
+                    .setDescription("The card number to summon")
                    .setRequired(true));
    }
    public override async execute(interaction: CommandInteraction<CacheType>) {
        if (!interaction.isChatInputCommand()) return;
-        const cardNumber = interaction.options.get('cardnumber');
+        const cardNumber = interaction.options.get("cardnumber");
        if (!cardNumber || !cardNumber.value) {
-            await interaction.reply('Card Number is required');
+            await interaction.reply("Card Number is required");
            return;
        }
@ -36,7 +36,7 @@ export default class Dropnumber extends Command {
            .find(x => x.id == cardNumber.value);
        if (!card) {
-            await interaction.reply('Card not found');
+            await interaction.reply("Card not found");
            return;
        }
@ -47,7 +47,7 @@ export default class Dropnumber extends Command {
        const imageFileName = card.path.split("/").pop()!;
        try {
-            image = readFileSync(path.join(process.env.DATA_DIR!, 'cards', card.path));
+            image = readFileSync(path.join(process.env.DATA_DIR!, "cards", card.path));
        } catch {
            await interaction.reply(`Unable to fetch image for card ${card.id}`);
            return;
@ -78,7 +78,7 @@ export default class Dropnumber extends Command {
            if (e instanceof DiscordAPIError) {
                await interaction.editReply(`Unable to send next drop. Please try again, and report this if it keeps happening. Code: ${e.code}`);
            } else {
-                await interaction.editReply(`Unable to send next drop. Please try again, and report this if it keeps happening. Code: UNKNOWN`);
+                await interaction.editReply("Unable to send next drop. Please try again, and report this if it keeps happening. Code: UNKNOWN");
            }
        }
--- a/src/commands/stage/droprarity.ts
+++ b/src/commands/stage/droprarity.ts
@ -12,37 +12,37 @@ export default class Droprarity extends Command {
    constructor() {
        super();
-        super.CommandBuilder = new SlashCommandBuilder()
+        this.CommandBuilder = new SlashCommandBuilder()
-            .setName('droprarity')
+            .setName("droprarity")
-            .setDescription('(TEST) Summon a random card of a specific rarity')
+            .setDescription("(TEST) Summon a random card of a specific rarity")
            .addStringOption(x =>
                x
-                    .setName('rarity')
+                    .setName("rarity")
-                    .setDescription('The rarity you want to summon')
+                    .setDescription("The rarity you want to summon")
                    .setRequired(true));
    }
    public override async execute(interaction: CommandInteraction<CacheType>) {
        if (!interaction.isChatInputCommand()) return;
-        const rarity = interaction.options.get('rarity');
+        const rarity = interaction.options.get("rarity");
        if (!rarity || !rarity.value) {
-            await interaction.reply('Rarity is required');
+            await interaction.reply("Rarity is required");
            return;
        }
        const rarityType = CardRarityParse(rarity.value.toString());
        if (rarityType == CardRarity.Unknown) {
-            await interaction.reply('Invalid rarity');
+            await interaction.reply("Invalid rarity");
            return;
        }
        const card = await CardDropHelperMetadata.GetRandomCardByRarity(rarityType);
        if (!card) {
-            await interaction.reply('Card not found');
+            await interaction.reply("Card not found");
            return;
        }
@ -50,7 +50,7 @@ export default class Droprarity extends Command {
        const imageFileName = card.card.path.split("/").pop()!;
        try {
-            image = readFileSync(path.join(process.env.DATA_DIR!, 'cards', card.card.path));
+            image = readFileSync(path.join(process.env.DATA_DIR!, "cards", card.card.path));
        } catch {
            await interaction.reply(`Unable to fetch image for card ${card.card.id}`);
            return;
@ -81,7 +81,7 @@ export default class Droprarity extends Command {
            if (e instanceof DiscordAPIError) {
                await interaction.editReply(`Unable to send next drop. Please try again, and report this if it keeps happening. Code: ${e.code}`);
            } else {
-                await interaction.editReply(`Unable to send next drop. Please try again, and report this if it keeps happening. Code: UNKNOWN`);
+                await interaction.editReply("Unable to send next drop. Please try again, and report this if it keeps happening. Code: UNKNOWN");
            }
        }
--- a/src/contracts/IButtonEventItem.ts
+++ b/src/contracts/IButtonEventItem.ts
@ -1,8 +1,10 @@
 import { Environment } from "../constants/Environment";
 import { ButtonEvent } from "../type/buttonEvent";
-export default interface IButtonEventItem {
+interface ButtonEventItem {
    ButtonId: string,
    Event: ButtonEvent,
    Environment: Environment,
 }
 export default ButtonEventItem;
--- a/src/contracts/EventExecutors.ts
+++ b/src/contracts/EventExecutors.ts
@ -0,0 +1,19 @@
 import { DMChannel, Guild, GuildBan, GuildMember, Message, NonThreadGuildBasedChannel, PartialGuildMember, PartialMessage } from "discord.js";
 interface EventExecutors {
    ChannelCreate: ((channel: NonThreadGuildBasedChannel) => void)[],
    ChannelDelete: ((channel: DMChannel | NonThreadGuildBasedChannel) => void)[],
    ChannelUpdate: ((channel: DMChannel | NonThreadGuildBasedChannel) => void)[],
    GuildBanAdd: ((ban: GuildBan) => void)[],
    GuildBanRemove: ((ban: GuildBan) => void)[],
    GuildCreate: ((guild: Guild) => void)[],
    GuildMemberAdd: ((member: GuildMember) => void)[],
    GuildMemberRemove: ((member: GuildMember | PartialGuildMember) => void)[],
    GuildMemebrUpdate: ((oldMember: GuildMember | PartialGuildMember, newMember: GuildMember) => void)[],
    MessageCreate: ((message: Message<boolean>) => void)[],
    MessageDelete: ((message: Message<boolean> | PartialMessage) => void)[],
    MessageUpdate: ((oldMessage: Message<boolean> | PartialMessage, newMessage: Message<boolean> | PartialMessage) => void)[],
 }
 export default EventExecutors;
--- a/src/contracts/ICommandItem.ts
+++ b/src/contracts/ICommandItem.ts
@ -1,9 +1,11 @@
 import { Environment } from "../constants/Environment";
 import { Command } from "../type/command";
-export default interface ICommandItem {
+interface ICommandItem {
    Name: string,
    Command: Command,
    Environment: Environment,
    ServerId?: string,
 }
 export default ICommandItem;
--- a/src/contracts/IEventItem.ts
+++ b/src/contracts/IEventItem.ts
@ -1,9 +0,0 @@
 import { Environment } from "../constants/Environment";
 import { EventType } from "../constants/EventType";
 export default interface IEventItem {
    EventType: EventType,
    ExecutionFunction: Function,
    Environment: Environment,
 }
--- a/src/contracts/IGDriveFolderListing.ts
+++ b/src/contracts/IGDriveFolderListing.ts
@ -1,4 +1,4 @@
-export default interface IGDriveFolderListing {
+export interface IGDriveFolderListing {
    id: string,
    name: string,
-};
+}
--- a/src/contracts/SeriesMetadata.ts
+++ b/src/contracts/SeriesMetadata.ts
@ -1,6 +1,6 @@
 import { CardRarity } from "../constants/CardRarity";
-export default interface SeriesMetadata {
+export interface SeriesMetadata {
    id: number,
    name: string,
    cards: CardMetadata[],
--- a/src/database/migrations/app/0.1.5/1694609771821-CreateClaim.ts
+++ b/src/database/migrations/app/0.1.5/1694609771821-CreateClaim.ts
@ -1,17 +1,17 @@
-import { MigrationInterface, QueryRunner } from "typeorm"
+import { MigrationInterface, QueryRunner } from "typeorm";
-import MigrationHelper from "../../../../helpers/MigrationHelper"
+import MigrationHelper from "../../../../helpers/MigrationHelper";
 export class CreateClaim1694609771821 implements MigrationInterface {
    public async up(queryRunner: QueryRunner): Promise<void> {
-        MigrationHelper.Up('1694609771821-CreateClaim', '0.1.5', [
+        MigrationHelper.Up("1694609771821-CreateClaim", "0.1.5", [
-            '01-CreateClaim',
+            "01-CreateClaim",
-            '02-MoveToClaim',
+            "02-MoveToClaim",
-            '03-AlterInventory',
+            "03-AlterInventory",
        ], queryRunner);
    }
-    public async down(queryRunner: QueryRunner): Promise<void> {
+    public async down(): Promise<void> {
    }
 }
--- a/src/database/migrations/app/0.1/1693769942868-CreateBase.ts
+++ b/src/database/migrations/app/0.1/1693769942868-CreateBase.ts
@ -1,15 +1,15 @@
-import { MigrationInterface, QueryRunner } from "typeorm"
+import { MigrationInterface, QueryRunner } from "typeorm";
-import MigrationHelper from "../../../../helpers/MigrationHelper"
+import MigrationHelper from "../../../../helpers/MigrationHelper";
 export class CreateBase1693769942868 implements MigrationInterface {
    public async up(queryRunner: QueryRunner): Promise<void> {
-        MigrationHelper.Up('1693769942868-CreateBase', '0.1', [
+        MigrationHelper.Up("1693769942868-CreateBase", "0.1", [
            "01-table/Inventory",
        ], queryRunner);
    }
-    public async down(queryRunner: QueryRunner): Promise<void> {
+    public async down(): Promise<void> {
    }
 }
--- a/src/database/migrations/app/0.2/1699814500650-createConfig.ts
+++ b/src/database/migrations/app/0.2/1699814500650-createConfig.ts
@ -1,15 +1,15 @@
-import { MigrationInterface, QueryRunner } from "typeorm"
+import { MigrationInterface, QueryRunner } from "typeorm";
-import MigrationHelper from "../../../../helpers/MigrationHelper"
+import MigrationHelper from "../../../../helpers/MigrationHelper";
 export class CreateConfig1699814500650 implements MigrationInterface {
    public async up(queryRunner: QueryRunner): Promise<void> {
-        MigrationHelper.Up('1699814500650-createConfig', '0.2', [
+        MigrationHelper.Up("1699814500650-createConfig", "0.2", [
            "01-table/Config",
        ], queryRunner);
    }
-    public async down(queryRunner: QueryRunner): Promise<void> {
+    public async down(): Promise<void> {
    }
 }
--- a/src/helpers/CardDropHelperMetadata.ts
+++ b/src/helpers/CardDropHelperMetadata.ts
@ -55,7 +55,7 @@ export default class CardDropHelperMetadata {
        return card;
    }
-    public static GenerateDropEmbed(drop: DropResult, quantityClaimed: Number, imageFileName: string): EmbedBuilder {
+    public static GenerateDropEmbed(drop: DropResult, quantityClaimed: number, imageFileName: string): EmbedBuilder {
        let description = "";
        description += `Series: ${drop.series.name}\n`;
        description += `Claimed: ${quantityClaimed}\n`;
@ -76,7 +76,7 @@ export default class CardDropHelperMetadata {
                    .setLabel("Claim")
                    .setStyle(ButtonStyle.Primary),
                new ButtonBuilder()
-                    .setCustomId(`reroll`)
+                    .setCustomId("reroll")
                    .setLabel("Reroll")
                    .setStyle(ButtonStyle.Secondary));
    }
--- a/src/helpers/InventoryHelper.ts
+++ b/src/helpers/InventoryHelper.ts
@ -1,7 +1,6 @@
 import { ActionRowBuilder, ButtonBuilder, ButtonStyle, EmbedBuilder } from "discord.js";
 import Inventory from "../database/entities/app/Inventory";
 import { CoreClient } from "../client/client";
 import SeriesMetadata from "../contracts/SeriesMetadata";
 import EmbedColours from "../constants/EmbedColours";
 import { CardRarity, CardRarityToString } from "../constants/CardRarity";
@ -37,14 +36,14 @@ export default class InventoryHelper {
        const pages: InventoryPage[] = [];
-        for (let series of allSeriesClaimed) {
+        for (const series of allSeriesClaimed) {
            const seriesCards = series.cards;
            for (let i = 0; i < seriesCards.length; i+= cardsPerPage) {
                const cards = series.cards.slice(i, i + cardsPerPage);
                const pageCards: InventoryPageCards[] = [];
-                for (let card of cards) {
+                for (const card of cards) {
                    const item = inventory.find(x => x.CardNumber == card.id);
                    if (!item) {
@ -77,7 +76,7 @@ export default class InventoryHelper {
        const embed = new EmbedBuilder()
            .setTitle(username)
-            .setDescription(`**${currentPage.name} (${currentPage.seriesSubpage + 1})**\n${currentPage.cards.map(x => `[${x.id}] ${x.name} (${CardRarityToString(x.type)}) x${x.quantity}`).join('\n')}`)
+            .setDescription(`**${currentPage.name} (${currentPage.seriesSubpage + 1})**\n${currentPage.cards.map(x => `[${x.id}] ${x.name} (${CardRarityToString(x.type)}) x${x.quantity}`).join("\n")}`)
            .setFooter({ text: `Page ${page + 1} of ${pages.length}` })
            .setColor(EmbedColours.Ok);
--- a/src/helpers/MigrationHelper.ts
+++ b/src/helpers/MigrationHelper.ts
@ -3,7 +3,7 @@ import { QueryRunner } from "typeorm";
 export default class MigrationHelper {
    public static Up(migrationName: string, version: string, queryFiles: string[], queryRunner: QueryRunner) {
-        for (let path of queryFiles) {
+        for (const path of queryFiles) {
            const query = readFileSync(`${process.cwd()}/database/${version}/${migrationName}/Up/${path}.sql`).toString();
            queryRunner.query(query);
@ -11,7 +11,7 @@ export default class MigrationHelper {
    }
    public static Down(migrationName: string, version: string, queryFiles: string[], queryRunner: QueryRunner) {
-        for (let path of queryFiles) {
+        for (const path of queryFiles) {
            const query = readFileSync(`${process.cwd()}/database/${version}/${migrationName}/Down/${path}.sql`).toString();
            queryRunner.query(query);
--- a/src/helpers/StringTools.ts
+++ b/src/helpers/StringTools.ts
@ -1,7 +1,7 @@
 export default class StringTools {
    public static Capitalise(str: string): string {
        const words = str.split(" ");
-        let result: string[] = [];
+        const result: string[] = [];
        words.forEach(word => {
            const firstLetter = word.substring(0, 1).toUpperCase();
@ -26,10 +26,10 @@ export default class StringTools {
    public static RandomString(length: number) {
        let result = "";
-        const characters = 'abcdefghkmnpqrstuvwxyz23456789';
+        const characters = "abcdefghkmnpqrstuvwxyz23456789";
        const charactersLength = characters.length;
-        for ( var i = 0; i < length; i++ ) {
+        for ( let i = 0; i < length; i++ ) {
            result += characters.charAt(Math.floor(Math.random() * charactersLength));
        }
@ -37,6 +37,6 @@ export default class StringTools {
    }
    public static ReplaceAll(str: string, find: string, replace: string) {
-        return str.replace(new RegExp(find, 'g'), replace);
+        return str.replace(new RegExp(find, "g"), replace);
    }
 }
--- a/src/helpers/TimeLengthInput.ts
+++ b/src/helpers/TimeLengthInput.ts
@ -4,23 +4,23 @@ export default class TimeLengthInput {
    public readonly value: string;
    constructor(input: string) {
-        this.value = StringTools.ReplaceAll(input, ',', '');
+        this.value = StringTools.ReplaceAll(input, ",", "");
    }
    public GetDays(): number {
-        return this.GetValue('d');
+        return this.GetValue("d");
    }
    public GetHours(): number {
-        return this.GetValue('h');
+        return this.GetValue("h");
    }
    public GetMinutes(): number {
-        return this.GetValue('m');
+        return this.GetValue("m");
    }
    public GetSeconds(): number {
-        return this.GetValue('s');
+        return this.GetValue("s");
    }
    public GetMilliseconds(): number {
@ -106,7 +106,7 @@ export default class TimeLengthInput {
    }
    private GetValue(designation: string): number {
-        const valueSplit = this.value.split(' ');
+        const valueSplit = this.value.split(" ");
        const desString = valueSplit.find(x => x.charAt(x.length - 1) == designation);
--- a/src/hooks/ReloadDB.ts
+++ b/src/hooks/ReloadDB.ts
@ -2,7 +2,7 @@ import { Request, Response } from "express";
 import CardMetadataFunction from "../Functions/CardMetadataFunction";
 export default async function ReloadDB(req: Request, res: Response) {
-    console.log('Reloading Card DB...');
+    console.log("Reloading Card DB...");
    await CardMetadataFunction.Execute();
--- a/src/registry.ts
+++ b/src/registry.ts
@ -21,16 +21,16 @@ import Reroll from "./buttonEvents/Reroll";
 export default class Registry {
    public static RegisterCommands() {
        // Global Commands
-        CoreClient.RegisterCommand('about', new About());
+        CoreClient.RegisterCommand("about", new About());
-        CoreClient.RegisterCommand('drop', new Drop());
+        CoreClient.RegisterCommand("drop", new Drop());
-        CoreClient.RegisterCommand('gdrivesync', new Gdrivesync());
+        CoreClient.RegisterCommand("gdrivesync", new Gdrivesync());
-        CoreClient.RegisterCommand('give', new Give());
+        CoreClient.RegisterCommand("give", new Give());
-        CoreClient.RegisterCommand('inventory', new Inventory());
+        CoreClient.RegisterCommand("inventory", new Inventory());
-        CoreClient.RegisterCommand('resync', new Resync());
+        CoreClient.RegisterCommand("resync", new Resync());
        // Test Commands
-        CoreClient.RegisterCommand('dropnumber', new Dropnumber(), Environment.Test);
+        CoreClient.RegisterCommand("dropnumber", new Dropnumber(), Environment.Test);
-        CoreClient.RegisterCommand('droprarity', new Droprarity(), Environment.Test);
+        CoreClient.RegisterCommand("droprarity", new Droprarity(), Environment.Test);
    }
    public static RegisterEvents() {
@ -38,8 +38,8 @@ export default class Registry {
    }
    public static RegisterButtonEvents() {
-        CoreClient.RegisterButtonEvent('claim', new Claim());
+        CoreClient.RegisterButtonEvent("claim", new Claim());
-        CoreClient.RegisterButtonEvent('inventory', new InventoryButtonEvent);
+        CoreClient.RegisterButtonEvent("inventory", new InventoryButtonEvent);
-        CoreClient.RegisterButtonEvent('reroll', new Reroll());
+        CoreClient.RegisterButtonEvent("reroll", new Reroll());
    }
 }
--- a/src/type/buttonEvent.ts
+++ b/src/type/buttonEvent.ts
@ -1,7 +1,5 @@
 import { ButtonInteraction } from "discord.js";
-export class ButtonEvent {
+export abstract class ButtonEvent {
-    public execute(interaction: ButtonInteraction) {
+    abstract execute(interaction: ButtonInteraction): Promise<void>;
    }
 }
--- a/src/type/command.ts
+++ b/src/type/command.ts
@ -1,9 +1,7 @@
-import { CommandInteraction } from "discord.js";
+import { CommandInteraction, SlashCommandBuilder } from "discord.js";
-export class Command {
+export abstract class Command {
-    public CommandBuilder: any;
+    public CommandBuilder: Omit<SlashCommandBuilder, "addSubcommand" | "addSubcommandGroup">;
    public execute(interaction: CommandInteraction) {
-    }
+    abstract execute(interaction: CommandInteraction): Promise<void>;
 }
--- a/src/webhooks.ts
+++ b/src/webhooks.ts
@ -19,7 +19,7 @@ export default class Webhooks {
    }
    private setupRoutes() {
-        this.app.post('/api/reload-db', ReloadDB);
+        this.app.post("/api/reload-db", ReloadDB);
    }
    private setupListen() {