create-djskit 0.0.0-stage → 1.0.0

package/template/src/context/Message/quote.ts

@@ -0,0 +1,17 @@
+import { ApplicationCommandType, Client, ContextMenuCommandBuilder, MessageContextMenuCommandInteraction, MessageFlags } from "discord.js";
+
+export default {
+
+    data: new ContextMenuCommandBuilder()
+    .setName("Quote Message")
+    .setType(ApplicationCommandType.Message),
+
+    async execute( interaction: MessageContextMenuCommandInteraction, client: Client ) {
+
+        const message = interaction.targetMessage;
+
+        await interaction.reply({ content: `> ${message.content || "*No text content*"}\n— ${message.author.displayName}`, flags: [MessageFlags.Ephemeral] });
+
+    }
+
+}

package/template/src/context/User/avatar.ts

@@ -0,0 +1,17 @@
+import { ApplicationCommandType, Client, ContextMenuCommandBuilder, MessageFlags, UserContextMenuCommandInteraction } from "discord.js";
+
+export default {
+
+    data: new ContextMenuCommandBuilder()
+    .setName("Show Avatar")
+    .setType(ApplicationCommandType.User),
+
+    async execute( interaction: UserContextMenuCommandInteraction, client: Client ) {
+
+        const user = interaction.targetUser;
+
+        await interaction.reply({ content: `${user.displayName}'s avatar: ${user.displayAvatarURL({ size: 1024 })}`, flags: [MessageFlags.Ephemeral] });
+
+    }
+
+}

package/template/src/events/Guild/msgCreate.ts

@@ -0,0 +1,16 @@
+import { Events, Client, Message } from "discord.js";
+
+export default {
+
+    data: {
+        event: Events.MessageCreate,
+        once: false,
+    },
+
+    async execute(client: Client, message: Message) {
+
+        console.log(message.content)
+
+    }
+
+}

package/template/src/handler/database.ts

@@ -0,0 +1,9 @@
+import DotDB from "dotdatabase";
+
+const database = {
+
+    config: new DotDB("src/database/config.json")
+
+}
+
+export default database;

package/template/src/handler/devMode.ts

@@ -0,0 +1,17 @@
+import "dotenv/config";
+import chalk from "chalk";
+import config from "../config";
+
+// DEV_MODE=true -> commands are registered to (and message commands only respond in) config.devGuildId
+// DEV_MODE=false -> commands are registered globally, even if a devGuildId is set
+
+let devMode = process.env.DEV_MODE?.trim().toLowerCase() === "true";
+
+if ( devMode && config.devGuildId === "" ) {
+
+    console.log(chalk.yellow.bold("[🌿]") + " " + chalk.yellow("DEV_MODE is enabled but no devGuildId is set in src/config.ts. Registering commands globally."));
+    devMode = false;
+
+}
+
+export default devMode;

package/template/src/handler/eventHandler.ts

@@ -0,0 +1,49 @@
+import { Client, Events } from "discord.js";
+import fs from "fs";
+import chalk from "chalk";
+
+const eventHandler = async (client: Client) => {
+
+    if (!client.isReady()) {
+        await new Promise((resolve) => client.once(Events.ClientReady, resolve));
+    }
+    
+    for (const directory of fs.readdirSync("./src/events")) {
+
+        if ( directory == ".DS_Store" ) continue;
+        if ( directory.startsWith("src") ) continue;
+    
+        for (const file of fs.readdirSync("./src/events/" + directory).filter((f) => f.endsWith(".ts"))) {
+
+            try {
+
+                const module = await import(`../events/${directory}/${file}`);
+                const event = module.default;
+
+                if (event.data.once) {
+                    client.once(event.data.event, (...args) => event.execute(client, ...args));
+                }
+
+                if (!event.data.once) {
+                    client.on(event.data.event, (...args) => event.execute(client, ...args));
+                }
+
+            } catch ( err ) {
+                
+                console.log(chalk.red.bold("[🌿]") + " " + chalk.red("There was an error while registering an event."));
+                console.log()
+                console.log(chalk.grey("------------------------------"))
+                console.log()
+                console.log(err);
+                console.log()
+                console.log(chalk.grey("------------------------------"))
+
+            }
+
+        }
+
+    }
+
+}
+
+export default eventHandler;

package/template/src/handler/listenerComponents.ts

@@ -0,0 +1,62 @@
+import { Client, Events, Interaction, MessageFlags } from "discord.js";
+import chalk from "chalk";
+
+const listenerComponents = async (client: Client, components: Map<string, any>) => {
+    client.on(Events.InteractionCreate, async (interaction: Interaction) => {
+        if (!interaction.isMessageComponent() && !interaction.isModalSubmit()) return;
+
+        const cId = interaction.customId.split(":")[0]
+        
+        const componentHandler = components.get(cId);
+        
+        if (!componentHandler) {
+            return;
+        }
+
+        if ( interaction.customId.split(":").length >= 3 ) {
+            return;
+        }
+        
+        let componentArgs: Record<string, string> = {};
+        const componentArgsString = interaction.customId.split(":")[1]
+
+        if (componentArgsString) {
+            const componentArgPairs = componentArgsString.includes("_")
+                ? componentArgsString.split("_")
+                : [componentArgsString];
+
+            for (const argPair of componentArgPairs) {
+                const [argKey, argVal] = argPair.split("=");
+                if (argKey && argVal !== undefined) {
+                    componentArgs[argKey] = argVal;
+                }
+            }
+        }
+
+        try {
+            await componentHandler.execute(interaction, client, componentArgs);
+        } catch (err) {
+            console.log(chalk.red.bold("[🌿]") + " " + chalk.red(`Error executing component handler for customId: ${interaction.customId}`));
+            console.log();
+            console.log(chalk.grey("------------------------------"));
+            console.log();
+            console.log(err);
+            console.log();
+            console.log(chalk.grey("------------------------------"));
+
+            if (interaction.isRepliable()) {
+                try {
+                    await interaction.reply({ content: "There was an error while executing this component interaction!", flags: [MessageFlags.Ephemeral] });
+                } catch (replyError) {
+                    console.log(chalk.red.bold("[🌿]") + " " + chalk.red("Failed to send error reply to interaction."));
+                    console.log(replyError);
+                }
+            }
+        }
+
+    }
+
+    );
+};
+
+export default listenerComponents;

package/template/src/handler/listenerMsgCommands.ts

@@ -0,0 +1,74 @@
+import "dotenv/config";
+import { Client, Events, Message } from "discord.js";
+import chalk from "chalk";
+import config from "../config";
+
+const listenerMsgCommands = async (client: Client, commands: Map<any, any>, guildOnly: boolean) => {
+
+    client.on(Events.MessageCreate, async (message: Message) => {
+
+        if (message.author.bot) return;
+
+        if ( guildOnly ) {
+
+            if ( message.guild?.id !== config.devGuildId ) return;
+
+        }
+
+        if ( message.content.startsWith(config.messageCommandPrefix) ) {
+
+            const commandName = message.content.slice(config.messageCommandPrefix.length).split(" ")[0];
+            const commandKey = `${config.messageCommandPrefix}${commandName}`;
+            const command = commands.get(commandKey);
+
+            if ( !command ) return;
+
+            try {
+
+                await command.execute(message, client, message.content.split(" ").slice(1));
+
+            } catch ( err ) {
+
+                console.log(chalk.red.bold("[🌿]") + " " + chalk.red("There was an error while executing " + message.content.split(" ")[0]));
+                console.log()
+                console.log(chalk.grey("------------------------------"))
+                console.log()
+                console.log(err);
+                console.log()
+                console.log(chalk.grey("------------------------------"))
+
+                return;
+
+            }
+
+            return;
+
+        };
+
+        for (const [commandKey, cmd] of commands.entries()) {
+
+            if (cmd.data.customPrefix && message.content.startsWith(cmd.data.customPrefix)) {
+                const commandName = message.content.slice(cmd.data.customPrefix.length).split(" ")[0];
+                
+                if (commandKey === `${cmd.data.customPrefix}${commandName}`) {
+                    try {
+                        await cmd.execute( message, client, message.content.slice(cmd.data.customPrefix.length).trim().split(" ") );
+                    } catch (err) {
+                        console.log(chalk.red.bold("[🌿]") + " " + chalk.red("There was an error while executing " + message.content.split(" ")[0]));
+                        console.log();
+                        console.log(chalk.grey("------------------------------"));
+                        console.log();
+                        console.log(err);
+                        console.log();
+                        console.log(chalk.grey("------------------------------"));
+                    }
+                    return;
+                }
+            }
+        }
+
+    });
+
+}
+
+export default listenerMsgCommands;

package/template/src/handler/listenerSlashCommands.ts

@@ -0,0 +1,89 @@
+import "dotenv/config";
+import { Client, Events, Interaction } from "discord.js";
+import chalk from "chalk";
+
+const listenerSlashCommands = async (client: Client, commands: Map<any, any>, contextCommands: Map<any, any>) => {
+
+    client.on(Events.InteractionCreate, async (interaction: Interaction) => {
+
+        if ( interaction.isAutocomplete() ) {
+
+            const command = commands.get(interaction.commandName);
+
+            if ( !command?.autocomplete ) return;
+
+            try {
+
+                await command.autocomplete(interaction, client);
+
+            } catch ( err ) {
+
+                console.log(chalk.red.bold("[🌿]") + " " + chalk.red("There was an error while autocompleting /" + interaction.commandName));
+                console.log()
+                console.log(chalk.grey("------------------------------"))
+                console.log()
+                console.log(err);
+                console.log()
+                console.log(chalk.grey("------------------------------"))
+
+            }
+
+            return;
+
+        }
+
+        if ( interaction.isContextMenuCommand() ) {
+
+            const command = contextCommands.get(`${interaction.commandType}:${interaction.commandName}`);
+
+            if ( !command ) return;
+
+            try {
+
+                await command.execute(interaction, client);
+
+            } catch ( err ) {
+
+                console.log(chalk.red.bold("[🌿]") + " " + chalk.red("There was an error while executing context menu command " + interaction.commandName));
+                console.log()
+                console.log(chalk.grey("------------------------------"))
+                console.log()
+                console.log(err);
+                console.log()
+                console.log(chalk.grey("------------------------------"))
+
+            }
+
+            return;
+
+        }
+
+        if ( !interaction.isChatInputCommand() ) return;
+
+        const command = commands.get(interaction.commandName);
+
+        if ( !command ) return;
+
+        try {
+            
+            await command.execute(interaction, client);
+
+        } catch ( err ) {
+            
+            console.log(chalk.red.bold("[🌿]") + " " + chalk.red("There was an error while executing /" + interaction.commandName));
+            console.log()
+            console.log(chalk.grey("------------------------------"))
+            console.log()
+            console.log(err);
+            console.log()
+            console.log(chalk.grey("------------------------------"))
+
+            return;
+
+        }
+
+    });
+
+}
+
+export default listenerSlashCommands;

package/template/src/handler/registerComponents.ts

@@ -0,0 +1,50 @@
+import "dotenv/config";
+import { Client, Events } from "discord.js";
+import fs from "fs";
+import path from "path";
+import chalk from "chalk";
+
+import listenerComponents from "./listenerComponents";
+
+const handlerRegisterComponents = async (client: Client) => {
+    if (!client.isReady()) {
+        await new Promise((resolve) => client.once(Events.ClientReady, resolve));
+    }
+
+    const components = new Map<string, any>();
+    const componentsBaseDir = path.join("./src/components");
+
+    for ( const typeDir of fs.readdirSync(componentsBaseDir) ) {
+
+        if ( typeDir == ".DS_Store" ) continue;
+        if ( typeDir.startsWith("src") ) continue;
+        
+        const typeDirPath = path.join(componentsBaseDir, typeDir);
+        if (!fs.statSync(typeDirPath).isDirectory()) continue;
+
+        for ( const componentFile of fs.readdirSync(typeDirPath).filter(file => file.endsWith(".js") || file.endsWith(".ts")) ) { // e.g., componentFile = "testButton.ts"
+            try {
+                const importPath = `../components/${typeDir}/${componentFile}`;
+                const module = await import(importPath);
+                const component = module.default;
+
+                if (component && typeof component.customId === 'string' && typeof component.execute === 'function') {
+                    components.set(component.customId, component);
+                } else {
+                    console.log(chalk.yellow.bold("[🌿]") + " " + chalk.yellow(`Skipping component file due to missing customId or execute function: ${componentFile}`));
+                }
+            } catch (err) {
+                console.log(chalk.red.bold("[🌿]") + " " + chalk.red(`Error registering component from file: ${componentFile}`));
+                console.log();
+                console.log(chalk.grey("------------------------------"));
+                console.log(err);
+                console.log();
+                console.log(chalk.grey("------------------------------"));
+            }
+        }
+    }
+
+    listenerComponents(client, components);
+};
+
+export default handlerRegisterComponents;

package/template/src/handler/registerMsgCommands.ts

@@ -0,0 +1,62 @@
+import "dotenv/config";
+import { Client, Events } from "discord.js";
+import config from "../config";
+import devMode from "./devMode";
+import fs from "fs";
+import chalk from "chalk";
+
+import listenerMsgCommands from "./listenerMsgCommands";
+
+const handlerRegisterMsgCommands = async (client: Client) => {
+
+    if (!client.isReady()) {
+        await new Promise((resolve) => client.once(Events.ClientReady, resolve));
+    }
+        
+    const commands = new Map();
+    
+    for (const directory of fs.readdirSync("./src/commands")) {
+
+        if ( directory == ".DS_Store" ) continue;
+        if ( directory.startsWith("src") ) continue;
+    
+        for (const file of fs.readdirSync("./src/commands/" + directory).filter((f) => f.endsWith(".ts"))) {
+
+            try {
+
+                const module = await import(`../commands/${directory}/${file}`);
+                const command = module.default;
+
+                if (
+                    typeof command.data?.toJSON === "function" &&
+                    command.data.constructor.name === "SlashCommandBuilder"
+                ) {
+                    continue;
+                }
+
+                const commandPrefix = command.data.customPrefix || config.messageCommandPrefix;
+                const commandKey = `${commandPrefix}${command.data.name}`;
+                
+                commands.set(commandKey, command);
+
+            } catch ( err ) {
+                
+                console.log(chalk.red.bold("[🌿]") + " " + chalk.red("There was an error while registering a message command."));
+                console.log()
+                console.log(chalk.grey("------------------------------"))
+                console.log()
+                console.log(err);
+                console.log()
+                console.log(chalk.grey("------------------------------"))
+
+            }
+
+        }
+
+    }
+
+    listenerMsgCommands(client, commands, devMode);
+
+}
+
+export default handlerRegisterMsgCommands;

package/template/src/handler/registerSlashCommands.ts

@@ -0,0 +1,148 @@
+import "dotenv/config";
+import { Client, Events, REST, Routes } from "discord.js";
+import config from "../config";
+import devMode from "./devMode";
+import fs from "fs";
+import chalk from "chalk";
+
+import listenerSlashCommands from "./listenerSlashCommands";
+
+// REST ----------------------------------------------------------------------------
+
+const restApi = new REST({ version: "10" }).setToken(process.env.CLIENT_TOKEN as string);
+
+// Register slash commands ---------------------------------------------------------
+
+const handlerRegisterSlashCommands = async (client: Client) => {
+
+    if (!client.isReady()) {
+        await new Promise((resolve) => client.once(Events.ClientReady, resolve));
+    }
+
+    const commands = new Map();
+    const contextCommands = new Map();
+    const slashCommandsData = [];
+
+    for (const directory of fs.readdirSync("./src/commands")) {
+
+        if ( directory == ".DS_Store" ) continue;
+        if ( directory.startsWith("src") ) continue;
+
+        for (const file of fs.readdirSync("./src/commands/" + directory).filter((f) => f.endsWith(".ts"))) {
+
+            try {
+
+                const module = await import(`../commands/${directory}/${file}`);
+                const command = module.default;
+
+                if (
+                    typeof command.data?.toJSON !== "function" ||
+                    command.data.constructor.name !== "SlashCommandBuilder"
+                ) {
+                    continue;
+                }
+
+                commands.set(command.data.name, command);
+                slashCommandsData.push(command.data);
+
+            } catch (err) {
+
+                console.log(chalk.red.bold("[🌿]") + " " + chalk.red("There was an error while processing a slash command."));
+                console.log();
+                console.log(chalk.grey("------------------------------"));
+                console.log();
+                console.log(err);
+                console.log();
+                console.log(chalk.grey("------------------------------"));
+
+            }
+
+        }
+
+    }
+
+    for (const directory of fs.readdirSync("./src/context")) {
+
+        if ( directory == ".DS_Store" ) continue;
+        if ( directory.startsWith("src") ) continue;
+
+        for (const file of fs.readdirSync("./src/context/" + directory).filter((f) => f.endsWith(".ts"))) {
+
+            try {
+
+                const module = await import(`../context/${directory}/${file}`);
+                const command = module.default;
+
+                if (
+                    typeof command.data?.toJSON !== "function" ||
+                    command.data.constructor.name !== "ContextMenuCommandBuilder"
+                ) {
+                    continue;
+                }
+
+                contextCommands.set(`${command.data.type}:${command.data.name}`, command);
+                slashCommandsData.push(command.data);
+
+            } catch (err) {
+
+                console.log(chalk.red.bold("[🌿]") + " " + chalk.red("There was an error while processing a context menu command."));
+                console.log();
+                console.log(chalk.grey("------------------------------"));
+                console.log();
+                console.log(err);
+                console.log();
+                console.log(chalk.grey("------------------------------"));
+
+            }
+
+        }
+
+    }
+
+    try {
+
+        if (!client.user?.id) return;
+
+        if (devMode) {
+
+            await restApi.put(
+                Routes.applicationGuildCommands(client.user.id, config.devGuildId),
+                { body: slashCommandsData }
+            );
+
+        } else {
+
+            await restApi.put(
+                Routes.applicationCommands(client.user.id),
+                { body: slashCommandsData }
+            );
+
+            // Clear leftover dev server commands, so they don't show up twice next to the global ones
+            if (config.devGuildId !== "") {
+
+                await restApi.put(
+                    Routes.applicationGuildCommands(client.user.id, config.devGuildId),
+                    { body: [] }
+                );
+
+            }
+
+        }
+
+    } catch (err) {
+
+        console.log(chalk.red.bold("[🌿]") + " " + chalk.red("There was an error while registering slash commands."));
+        console.log();
+        console.log(chalk.grey("------------------------------"));
+        console.log();
+        console.log(err);
+        console.log();
+        console.log(chalk.grey("------------------------------"));
+
+    }
+
+    listenerSlashCommands(client, commands, contextCommands);
+
+};
+
+export default handlerRegisterSlashCommands;