feat!: Module-based command system rewrite #2

+1 -13

README.md

··· 9 9 10 10 ## Roadmap 11 11 12 12 - - [ ] Add basic moderation stuff 12 12 + - [X] Add basic moderation stuff 13 13 - [ ] Some fun command I guess (?) 14 14 - [ ] Idk what to write here but you can go ahead and write an suggestion 15 15 - 16 16 - To install dependencies: 17 17 - 18 18 - ```bash 19 19 - bun install 20 20 - ``` 21 21 - 22 22 - To run: 23 23 - 24 24 - ```bash 25 25 - bun run index.ts 26 26 - ```

+23 -6

src/args.ts

··· 243 243 schema: StandardSchemaV1, 244 244 value: unknown, 245 245 ): Promise<unknown> { 246 246 - let result = schema["~standard"].validate(value); 247 247 - if (result instanceof Promise) result = await result; 248 248 - if (result.issues) { 249 249 - const messages = result.issues.map((i) => i.message).join(", "); 250 250 - throw new Error(`Argument "${key}": ${messages}`); 246 246 + const standard = schema["~standard"]; 247 247 + 248 248 + if (standard && typeof standard.validate === "function") { 249 249 + let result = standard.validate(value); 250 250 + if (result instanceof Promise) result = await result; 251 251 + if (result.issues) { 252 252 + const messages = result.issues.map((i) => i.message).join(", "); 253 253 + throw new Error(`Argument "${key}": ${messages}`); 254 254 + } 255 255 + return result.value; 256 256 + } 257 257 + 258 258 + if ("safeParse" in schema && typeof schema.safeParse === "function") { 259 259 + const result = await schema.safeParse(value); 260 260 + if (!result.success) { 261 261 + const messages = (result as { error?: { issues?: Array<{ message: string }> } }).error?.issues 262 262 + ?.map((i) => i.message) 263 263 + .join(", "); 264 264 + throw new Error(`Argument "${key}": ${messages ?? "Validation failed"}`); 265 265 + } 266 266 + return (result as { data: unknown }).data; 251 267 } 252 252 - return result.value; 268 268 + 269 269 + throw new Error(`Argument "${key}": Schema does not implement StandardSchemaV1 or safeParse`); 253 270 } 254 271 255 272 export async function parseArgs<S extends ArgSchema>(

+31

src/base/ModuleBase.ts

··· 1 1 + import "reflect-metadata"; 2 2 + import { Message } from "@fluxerjs/core"; 3 3 + import type { ArgSchema } from "@/args"; 4 4 + 5 5 + export interface ModuleMeta { 6 6 + name: string; 7 7 + description?: string; 8 8 + } 9 9 + 10 10 + export const MODULE_META_KEY = Symbol("fluxer:module"); 11 11 + export const MODULE_COMMANDS_KEY = Symbol("fluxer:module-commands"); 12 12 + 13 13 + export interface CommandMethodMeta { 14 14 + name: string; 15 15 + aliases?: string[]; 16 16 + description: string; 17 17 + args?: ArgSchema; 18 18 + } 19 19 + 20 20 + export interface ModuleCommand { 21 21 + methodName: string; 22 22 + meta: CommandMethodMeta; 23 23 + } 24 24 + 25 25 + export type Guard = (msg: Message) => boolean | Promise<boolean>; 26 26 + 27 27 + export function Module(meta: ModuleMeta & { guards?: Guard[] }): ClassDecorator { 28 28 + return (target) => { 29 29 + Reflect.defineMetadata(MODULE_META_KEY, meta, target); 30 30 + }; 31 31 + }

+2 -4

src/bot.ts

··· 1 1 import { Client, Events, Message } from "@fluxerjs/core"; 2 2 import { env } from "@/env"; 3 3 import { CommandRegistry } from "@/registry/commandRegistry"; 4 4 - import { loadCommands } from "@/registry/loadCommands"; 4 4 + import { loadModules } from "@/registry/loadModules"; 5 5 import { watchCommands } from "@/registry/watchCommands"; 6 6 import { Logger } from "tslog"; 7 7 ··· 34 34 async start() { 35 35 this.logger.info("Starting Hydro..."); 36 36 37 37 - await loadCommands(this.registry, env.PREFIX); 37 37 + await loadModules(this.registry, env.PREFIX); 38 38 39 39 if (IS_DEV) { 40 40 watchCommands(this.registry, env.PREFIX); 41 41 } 42 42 43 43 - // Registers events before logging in. 44 43 this.registerEvents(); 45 44 46 46 - // After loading commands and registering events, we can now login our bot 47 45 await this.client.login(env.FLUXER_BOT_TOKEN); 48 46 } 49 47 }

-89

src/commands/ban.ts

··· 1 1 - import { z } from "zod"; 2 2 - import { EmbedBuilder, type Message } from "@fluxerjs/core"; 3 3 - import { arg } from "@/args"; 4 4 - import { Command } from "@/decorators/command"; 5 5 - import { RequireNonBot } from "@/decorators/guards"; 6 6 - import type { BotContext, ICommand, ParsedArgs } from "@/types"; 7 7 - import { ColorPalette } from "@/utils"; 8 8 - 9 9 - const banArgs = { 10 10 - target: arg.string(), 11 11 - /** Specifies the ban duration in seconds (max one whole week: 604800) */ 12 12 - duration: z.coerce.number().int().positive().max(604800), 13 13 - /** Number of days of messages to delete (0-7) */ 14 14 - delete_messages_day: arg.optional(z.coerce.number().int().min(0).max(7)), 15 15 - /** 16 16 - * Reason for the ban — greedily consumes all remaining tokens. 17 17 - * Must be last. e.g. !ban @user 86400 1 Being rude in chat 18 18 - */ 19 19 - reason: arg.restOptional(z.string().min(1).max(500)), 20 20 - } as const; 21 21 - 22 22 - @Command({ name: "ban", description: "Bans a user" }) 23 23 - @RequireNonBot() 24 24 - export class BanCommand implements ICommand<typeof banArgs> { 25 25 - readonly args = banArgs; 26 26 - 27 27 - async execute( 28 28 - _ctx: BotContext, 29 29 - message: Message, 30 30 - args: ParsedArgs<typeof banArgs>, 31 31 - ): Promise<void> { 32 32 - try { 33 33 - const palette = new ColorPalette(); 34 34 - const guild = message.guild; 35 35 - if (!guild) throw new Error("This command can only be used in a server"); 36 36 - 37 37 - const mentionedUser = message.mentions[0]; 38 38 - if (!mentionedUser) throw new Error("Please mention a user to ban"); 39 39 - 40 40 - const member = await guild.fetchMember(mentionedUser.id); 41 41 - if (!member) throw new Error("I couldn't find a member to ban :("); 42 42 - 43 43 - const embed = new EmbedBuilder() 44 44 - .setTitle(`You've been banned from "${message.guild?.name}"`) 45 45 - .addFields( 46 46 - { 47 47 - name: "Reason", 48 48 - value: args.reason || "No reason provided", 49 49 - }, 50 50 - { 51 51 - name: "Ban Duration", 52 52 - value: `${args.duration > 0 ? args.duration : "Permament"}`, 53 53 - }, 54 54 - { 55 55 - name: "By", 56 56 - value: 57 57 - message.author.globalName || 58 58 - `${message.author.username}#${message.author.discriminator}`, 59 59 - }, 60 60 - ) 61 61 - .setColor(palette.get("red")) 62 62 - .setFooter({ 63 63 - text: "This message is automated, you will receive when someone takes action against you", 64 64 - }); 65 65 - 66 66 - await member.user.send({ 67 67 - embeds: [embed], 68 68 - }); 69 69 - 70 70 - await guild.ban(member.id, { 71 71 - ban_duration_seconds: args.duration, 72 72 - reason: args.reason ?? undefined, 73 73 - delete_message_days: args.delete_messages_day ?? undefined, 74 74 - }); 75 75 - 76 76 - const successMessage = await message.reply({ 77 77 - content: `Successfully banned **${member.displayName}**`, 78 78 - }); 79 79 - 80 80 - if (successMessage) setTimeout(() => successMessage.delete().catch(() => {}), 5000); 81 81 - } catch (e) { 82 82 - if (e instanceof Error) { 83 83 - await message.reply({ 84 84 - content: `Failed to ban this user\n\`\`\`\n${e.message}\n\`\`\``, 85 85 - }); 86 86 - } 87 87 - } 88 88 - } 89 89 - }

-48

src/commands/bulkdelete.ts

··· 1 1 - import { z } from "zod"; 2 2 - import { type Message, Client } from "@fluxerjs/core"; 3 3 - import { Command } from "@/decorators/command"; 4 4 - import { RequireNonBot } from "@/decorators/guards"; 5 5 - import type { BotContext, ICommand, ParsedArgs } from "@/types"; 6 6 - 7 7 - const bulkDeleteArgs = { 8 8 - count: z.coerce.number().int().min(2).max(100), 9 9 - } as const; 10 10 - 11 11 - @Command({ 12 12 - name: "bulkdelete", 13 13 - aliases: ["purge", "clear"], 14 14 - description: "Bulk deletes recent messages", 15 15 - }) 16 16 - @RequireNonBot() 17 17 - export class BulkDeleteCommand implements ICommand<typeof bulkDeleteArgs> { 18 18 - readonly args = bulkDeleteArgs; 19 19 - 20 20 - async execute( 21 21 - ctx: BotContext, 22 22 - message: Message, 23 23 - args: ParsedArgs<typeof bulkDeleteArgs>, 24 24 - ): Promise<void> { 25 25 - const { client } = ctx; 26 26 - 27 27 - const messages = await client.rest.get<Array<{ id: string }>>( 28 28 - `${Client.Routes.channelMessages(message.channelId)}?limit=${args.count}`, 29 29 - ); 30 30 - 31 31 - const messageIds = messages.map((m) => m.id); 32 32 - 33 33 - if (messageIds.length < 2) { 34 34 - await message.reply("Need at least 2 messages to bulk delete."); 35 35 - return; 36 36 - } 37 37 - 38 38 - const channel = await client.channels.resolve(message.channelId); 39 39 - await channel.bulkDeleteMessages(messageIds); 40 40 - 41 41 - const confirm = await message.channel?.send({ 42 42 - content: `Deleted ${args.count}`, 43 43 - }); 44 44 - 45 45 - // Auto-delete the confirmation after 5 seconds 46 46 - if (confirm) setTimeout(() => confirm.delete().catch(() => {}), 5000); 47 47 - } 48 48 - }

-28

src/commands/echo.ts

··· 1 1 - import { z } from "zod"; 2 2 - import type { Message } from "@fluxerjs/core"; 3 3 - import { arg } from "@/args"; 4 4 - import { Command } from "@/decorators/command"; 5 5 - import { RequireNonBot } from "@/decorators/guards"; 6 6 - import type { BotContext, ICommand, ParsedArgs } from "../types"; 7 7 - 8 8 - const echoArgs = { 9 9 - content: arg.restRequired(z.string().min(1).max(2000)), 10 10 - } as const; 11 11 - 12 12 - @Command({ 13 13 - name: "echo", 14 14 - aliases: ["say", "print"], 15 15 - description: "Repeats the content of the message", 16 16 - }) 17 17 - @RequireNonBot() 18 18 - export class EchoCommand implements ICommand<typeof echoArgs> { 19 19 - readonly args = echoArgs; 20 20 - 21 21 - async execute( 22 22 - _ctx: BotContext, 23 23 - message: Message, 24 24 - args: ParsedArgs<typeof echoArgs>, 25 25 - ): Promise<void> { 26 26 - await message.channel?.send({ content: args.content }); 27 27 - } 28 28 - }

-65

src/commands/kick.ts

··· 1 1 - import { Command } from "@/decorators/command"; 2 2 - import { arg } from "@/args"; 3 3 - import z from "zod"; 4 4 - import { RequireNonBot, RequireUserPermission } from "@/decorators/guards"; 5 5 - import type { BotContext, ICommand, ParsedArgs } from "@/types"; 6 6 - import { EmbedBuilder, type Message } from "@fluxerjs/core"; 7 7 - import { ColorPalette } from "@/utils"; 8 8 - 9 9 - const kickArgs = { 10 10 - target: arg.string(), 11 11 - reason: arg.restOptional(z.coerce.string().max(2000)), 12 12 - } as const; 13 13 - 14 14 - @Command({ 15 15 - name: "warn", 16 16 - aliases: ["w"], 17 17 - description: "Warns to a speficied user", 18 18 - }) 19 19 - @RequireNonBot() 20 20 - @RequireUserPermission({ 21 21 - permissions: ["Administrator", "KickMembers", "BanMembers"], 22 22 - mode: "any", 23 23 - }) 24 24 - export class WarnCommand implements ICommand<typeof kickArgs> { 25 25 - readonly args = kickArgs; 26 26 - 27 27 - async execute(_: BotContext, message: Message, args: ParsedArgs<typeof kickArgs>): Promise<void> { 28 28 - const palette = new ColorPalette(); 29 29 - const guild = message.guild; 30 30 - if (!guild) throw new Error("This command can only be used in a server"); 31 31 - 32 32 - const mentionedUser = message.mentions[0]; 33 33 - if (!mentionedUser) throw new Error("Please mention a user to warn"); 34 34 - 35 35 - const member = await message.guild?.fetchMember(mentionedUser.id); 36 36 - if (!member) throw new Error("I couldn't find a member to warn :("); 37 37 - 38 38 - const embed = new EmbedBuilder() 39 39 - .setTitle(`You've been kicked from "${message.guild?.name}"`) 40 40 - .addFields( 41 41 - { 42 42 - name: "Reason", 43 43 - value: args.reason || "No reason provided", 44 44 - }, 45 45 - { 46 46 - name: "By", 47 47 - value: 48 48 - message.author.globalName || 49 49 - `${message.author.username}#${message.author.discriminator}`, 50 50 - }, 51 51 - ) 52 52 - .setColor(palette.get("red")) 53 53 - .setFooter({ 54 54 - text: "This message is automated, you will receive when someone takes action against you", 55 55 - }); 56 56 - 57 57 - await member.user.send({ 58 58 - embeds: [embed], 59 59 - }); 60 60 - 61 61 - await guild.kick(member.id); 62 62 - 63 63 - message.reply(`Successfully warned ${member.displayName} for: ${args.reason}`); 64 64 - } 65 65 - }

+37

src/commands/misc.ts

··· 1 1 + import { RequireNonBot } from "@/decorators/guards"; 2 2 + import { Module } from "@/base/ModuleBase"; 3 3 + import { Command } from "@/decorators/command"; 4 4 + import type { BotContext, ParsedArgs } from "@/types"; 5 5 + import type { Message } from "@fluxerjs/core"; 6 6 + import { arg } from "@/args"; 7 7 + import { z } from "zod"; 8 8 + 9 9 + // Types 10 10 + const echoArgs = { 11 11 + content: arg.restRequired(z.string().min(1).max(2000)), 12 12 + } as const; 13 13 + 14 14 + // Module 15 15 + @Module({ 16 16 + name: "misc", 17 17 + description: "Miscellaneous commands", 18 18 + guards: [RequireNonBot()], 19 19 + }) 20 20 + export class MiscCommands { 21 21 + @Command({ 22 22 + name: "echo", 23 23 + description: "Echoes the provided content", 24 24 + args: echoArgs, 25 25 + }) 26 26 + async echo(_ctx: BotContext, message: Message, args: ParsedArgs<typeof echoArgs>): Promise<void> { 27 27 + await message.channel?.send({ content: args.content }); 28 28 + } 29 29 + 30 30 + @Command({ 31 31 + name: "ping", 32 32 + description: "Pings the bot", 33 33 + }) 34 34 + async ping(_ctx: BotContext, message: Message): Promise<void> { 35 35 + await message.channel?.send({ content: "Pong!" }); 36 36 + } 37 37 + }

+211

src/commands/moderation.ts

··· 1 1 + import { arg } from "@/args"; 2 2 + import { Module } from "@/base/ModuleBase"; 3 3 + import { db } from "@/db"; 4 4 + import { warnsTable } from "@/db/schemas"; 5 5 + import { Command } from "@/decorators/command"; 6 6 + import { RequireGuild, RequireNonBot, RequireUserPermission } from "@/decorators/guards"; 7 7 + import type { BotContext, ParsedArgs } from "@/types"; 8 8 + import { ColorPalette } from "@/utils"; 9 9 + import { Client, EmbedBuilder, type Message } from "@fluxerjs/core"; 10 10 + import z from "zod"; 11 11 + 12 12 + // Types 13 13 + 14 14 + const banArgs = { 15 15 + target: arg.string(), 16 16 + duration: z.coerce.number().int().positive().max(604800), 17 17 + delete_messages_day: arg.optional(z.coerce.number().int().min(0).max(7)), 18 18 + reason: arg.restOptional(z.string().min(1).max(500)), 19 19 + } as const; 20 20 + 21 21 + const warnArgs = { 22 22 + target: arg.string(), 23 23 + reason: arg.restOptional(z.coerce.string().max(2000)), 24 24 + } as const; 25 25 + 26 26 + const purgeArgs = { 27 27 + count: z.coerce.number().int().min(2).max(100), 28 28 + } as const; 29 29 + 30 30 + type WarnsInsertType = typeof warnsTable.$inferInsert; 31 31 + 32 32 + // Module 33 33 + 34 34 + @Module({ 35 35 + name: "mod", 36 36 + description: "Moderation stuff", 37 37 + guards: [ 38 38 + RequireNonBot(), 39 39 + RequireUserPermission({ 40 40 + mode: "any", 41 41 + permissions: ["Administrator", "KickMembers", "BanMembers"], 42 42 + }), 43 43 + RequireGuild(), 44 44 + ], 45 45 + }) 46 46 + export class ModerationModule { 47 47 + private readonly palette = new ColorPalette(); 48 48 + 49 49 + @Command({ 50 50 + name: "ban", 51 51 + description: "Ban a member", 52 52 + args: banArgs, 53 53 + }) 54 54 + async ban(_: BotContext, msg: Message, args: ParsedArgs<typeof banArgs>) { 55 55 + const guild = msg.guild; 56 56 + const mentionedUser = msg.mentions[0]; 57 57 + if (!mentionedUser) throw new Error("Please mention an user to ban."); 58 58 + 59 59 + const member = await guild?.fetchMember(mentionedUser.id); 60 60 + if (!member) throw new Error("I couldn't find a member to ban :("); 61 61 + 62 62 + const embed = new EmbedBuilder() 63 63 + .setTitle(`You've been banned from "${msg.guild?.name}"`) 64 64 + .addFields( 65 65 + { 66 66 + name: "Reason", 67 67 + value: args.reason || "No reason provided", 68 68 + }, 69 69 + { 70 70 + name: "Ban Duration", 71 71 + value: `${args.duration > 0 ? args.duration : "Permament"}`, 72 72 + }, 73 73 + { 74 74 + name: "By", 75 75 + value: msg.author.globalName || `${msg.author.username}#${msg.author.discriminator}`, 76 76 + }, 77 77 + ) 78 78 + .setColor(this.palette.get("red")) 79 79 + .setFooter({ 80 80 + text: "This message is automated, you will receive when someone takes action against you", 81 81 + }); 82 82 + 83 83 + await member.user.send({ 84 84 + embeds: [embed], 85 85 + }); 86 86 + 87 87 + await guild?.ban(member.id, { 88 88 + ban_duration_seconds: args.duration, 89 89 + reason: args.reason ?? undefined, 90 90 + delete_message_days: args.delete_messages_day ?? undefined, 91 91 + }); 92 92 + 93 93 + const successMessage = await msg.reply({ 94 94 + content: `Successfully banned **${member.displayName}**`, 95 95 + }); 96 96 + 97 97 + if (successMessage) setTimeout(() => successMessage.delete().catch(() => {}), 5000); 98 98 + } 99 99 + 100 100 + @Command({ 101 101 + name: "kick", 102 102 + description: "Kicks a member", 103 103 + args: warnArgs, 104 104 + }) 105 105 + async kick(_: BotContext, msg: Message, args: ParsedArgs<typeof warnArgs>) { 106 106 + const guild = msg.guild; 107 107 + 108 108 + const mentionedUser = msg.mentions[0]; 109 109 + if (!mentionedUser) throw new Error("Please mention a user to kick"); 110 110 + 111 111 + const member = await msg.guild?.fetchMember(mentionedUser.id); 112 112 + if (!member) throw new Error("I couldn't find a member to kick :("); 113 113 + 114 114 + const embed = new EmbedBuilder() 115 115 + .setTitle(`You've been kicked from "${msg.guild?.name}"`) 116 116 + .addFields( 117 117 + { 118 118 + name: "Reason", 119 119 + value: args.reason || "No reason provided", 120 120 + }, 121 121 + { 122 122 + name: "By", 123 123 + value: msg.author.globalName || `${msg.author.username}#${msg.author.discriminator}`, 124 124 + }, 125 125 + ) 126 126 + .setColor(this.palette.get("red")) 127 127 + .setFooter({ 128 128 + text: "This message is automated, you will receive when someone takes action against you", 129 129 + }); 130 130 + 131 131 + await member.user.send({ 132 132 + embeds: [embed], 133 133 + }); 134 134 + 135 135 + await guild?.kick(member.id); 136 136 + 137 137 + msg.reply(`Successfully kicked ${member.displayName} for: ${args.reason}`); 138 138 + } 139 139 + 140 140 + @Command({ 141 141 + name: "warn", 142 142 + description: "Warn a member", 143 143 + args: warnArgs, 144 144 + }) 145 145 + async warn(_: BotContext, msg: Message, args: ParsedArgs<typeof warnArgs>) { 146 146 + const guild = msg.guild; 147 147 + if (!guild) throw new Error("This command can only be used in a server"); 148 148 + 149 149 + const mentionedUser = msg.mentions[0]; 150 150 + if (!mentionedUser) throw new Error("Please mention a user to warn"); 151 151 + 152 152 + const member = await msg.guild?.fetchMember(mentionedUser.id); 153 153 + if (!member) throw new Error("I couldn't find a member to warn :("); 154 154 + 155 155 + const embed = new EmbedBuilder() 156 156 + .setTitle(`You've been warned from "${msg.guild?.name}"`) 157 157 + .setDescription( 158 158 + `Reason: ${args.reason}\nBy ${msg.author.globalName || `${msg.author.username}#${msg.author.discriminator}`}`, 159 159 + ) 160 160 + .setColor(this.palette.get("yellow")) 161 161 + .setFooter({ 162 162 + text: "This message is automated, you will receive when someone takes action against you.", 163 163 + }); 164 164 + 165 165 + await member.user.send({ 166 166 + embeds: [embed], 167 167 + }); 168 168 + 169 169 + const insertValues: WarnsInsertType = { 170 170 + guildId: guild.id, 171 171 + userId: member.id, 172 172 + moderator: msg.author.id, 173 173 + reason: args.reason ?? "", 174 174 + createdAt: new Date(Date.now()), 175 175 + }; 176 176 + 177 177 + await db.insert(warnsTable).values(insertValues); 178 178 + 179 179 + msg.reply(`Successfully warned ${member.displayName} for: ${args.reason}`); 180 180 + } 181 181 + 182 182 + @Command({ 183 183 + name: "purge", 184 184 + description: "Purges a number of messages", 185 185 + args: purgeArgs, 186 186 + }) 187 187 + async purge(ctx: BotContext, msg: Message, args: ParsedArgs<typeof purgeArgs>) { 188 188 + const { client } = ctx; 189 189 + 190 190 + const messages = await client.rest.get<Array<{ id: string }>>( 191 191 + `${Client.Routes.channelMessages(msg.channelId)}?limit=${args.count}`, 192 192 + ); 193 193 + 194 194 + const messageIds = messages.map((m) => m.id); 195 195 + 196 196 + if (messageIds.length < 2) { 197 197 + await msg.reply("Need at least 2 messages to bulk delete."); 198 198 + return; 199 199 + } 200 200 + 201 201 + const channel = await client.channels.resolve(msg.channelId); 202 202 + await channel.bulkDeleteMessages(messageIds); 203 203 + 204 204 + const confirm = await msg.channel?.send({ 205 205 + content: `Deleted ${args.count}`, 206 206 + }); 207 207 + 208 208 + // Auto-delete the confirmation after 5 seconds 209 209 + if (confirm) setTimeout(() => confirm.delete().catch(() => {}), 5000); 210 210 + } 211 211 + }

-12

src/commands/ping.ts

··· 1 1 - import type { Message } from "@fluxerjs/core"; 2 2 - import { Command } from "@/decorators/command"; 3 3 - import { RequireNonBot } from "@/decorators/guards"; 4 4 - import type { BotContext, ICommand } from "@/types"; 5 5 - 6 6 - @Command({ name: "ping", aliases: ["p"], description: 'Replies with "Pong!"' }) 7 7 - @RequireNonBot() 8 8 - export class PingCommand implements ICommand { 9 9 - async execute(_: BotContext, message: Message): Promise<void> { 10 10 - await message.reply("Pong!"); 11 11 - } 12 12 - }

-68

src/commands/warn.ts

··· 1 1 - import { Command } from "@/decorators/command"; 2 2 - import { arg } from "@/args"; 3 3 - import z from "zod"; 4 4 - import { RequireNonBot, RequireUserPermission } from "@/decorators/guards"; 5 5 - import type { BotContext, ICommand, ParsedArgs } from "@/types"; 6 6 - import { EmbedBuilder, type Message } from "@fluxerjs/core"; 7 7 - import { ColorPalette } from "@/utils"; 8 8 - import { warnsTable } from "@/db/schemas"; 9 9 - import { db } from "@/db"; 10 10 - 11 11 - const warnArgs = { 12 12 - target: arg.string(), 13 13 - reason: arg.restOptional(z.coerce.string().max(2000)), 14 14 - } as const; 15 15 - 16 16 - type WarnsInsertType = typeof warnsTable.$inferInsert; 17 17 - 18 18 - @Command({ 19 19 - name: "warn", 20 20 - aliases: ["w"], 21 21 - description: "Warns to a speficied user", 22 22 - }) 23 23 - @RequireNonBot() 24 24 - @RequireUserPermission({ 25 25 - permissions: ["Administrator", "KickMembers", "BanMembers"], 26 26 - mode: "any", 27 27 - }) 28 28 - export class WarnCommand implements ICommand<typeof warnArgs> { 29 29 - readonly args = warnArgs; 30 30 - 31 31 - async execute(_: BotContext, message: Message, args: ParsedArgs<typeof warnArgs>): Promise<void> { 32 32 - const palette = new ColorPalette(); 33 33 - const guild = message.guild; 34 34 - if (!guild) throw new Error("This command can only be used in a server"); 35 35 - 36 36 - const mentionedUser = message.mentions[0]; 37 37 - if (!mentionedUser) throw new Error("Please mention a user to warn"); 38 38 - 39 39 - const member = await message.guild?.fetchMember(mentionedUser.id); 40 40 - if (!member) throw new Error("I couldn't find a member to warn :("); 41 41 - 42 42 - const embed = new EmbedBuilder() 43 43 - .setTitle(`You've been warned from "${message.guild?.name}"`) 44 44 - .setDescription( 45 45 - `Reason: ${args.reason}\nBy ${message.author.globalName || `${message.author.username}#${message.author.discriminator}`}`, 46 46 - ) 47 47 - .setColor(palette.get("yellow")) 48 48 - .setFooter({ 49 49 - text: "This message is automated, you will receive when someone takes action against you.", 50 50 - }); 51 51 - 52 52 - await member.user.send({ 53 53 - embeds: [embed], 54 54 - }); 55 55 - 56 56 - const insertValues: WarnsInsertType = { 57 57 - guildId: guild.id, 58 58 - userId: member.id, 59 59 - moderator: message.author.id, 60 60 - reason: args.reason ?? "", 61 61 - createdAt: new Date(Date.now()), 62 62 - }; 63 63 - 64 64 - await db.insert(warnsTable).values(insertValues); 65 65 - 66 66 - message.reply(`Successfully warned ${member.displayName} for: ${args.reason}`); 67 67 - } 68 68 - }

+10 -3

src/decorators/command.ts

··· 1 1 import "reflect-metadata"; 2 2 + import type { ArgSchema } from "@/args"; 3 3 + import { MODULE_COMMANDS_KEY } from "@/base/ModuleBase"; 2 4 3 5 export interface CommandMeta { 4 6 name: string; 5 7 aliases?: string[]; 6 8 description: string; 9 9 + args?: ArgSchema; 7 10 } 8 11 9 12 export const COMMAND_META_KEY = Symbol("fluxer:command"); 10 13 11 11 - export function Command(meta: CommandMeta): ClassDecorator { 12 12 - return (target) => { 13 13 - Reflect.defineMetadata(COMMAND_META_KEY, meta, target); 14 14 + export function Command(meta: CommandMeta): MethodDecorator { 15 15 + return (_target, methodName) => { 16 16 + if (typeof methodName !== "string") return; 17 17 + const commands: Array<{ methodName: string; meta: CommandMeta }> = 18 18 + Reflect.getMetadata(MODULE_COMMANDS_KEY, _target.constructor) ?? []; 19 19 + commands.push({ methodName, meta }); 20 20 + Reflect.defineMetadata(MODULE_COMMANDS_KEY, commands, _target.constructor); 14 21 }; 15 22 }

+35 -11

src/decorators/guards.ts

··· 10 10 export const GUARDS_KEY = Symbol("fluxer:guards"); 11 11 export type Guard = (msg: Message) => boolean | Promise<boolean>; 12 12 13 13 - export function RequireNonBot(): ClassDecorator { 13 13 + export function RequireNonBot(): Guard { 14 14 + return (msg) => !msg.author.bot; 15 15 + } 16 16 + 17 17 + export function RequirePrefix(prefix: string): Guard { 18 18 + return (msg) => msg.content.startsWith(prefix); 19 19 + } 20 20 + 21 21 + export function RequireUserPermission(meta: RequireUserPermissionMeta): Guard { 22 22 + return async (msg) => { 23 23 + const permission = await GetMemeberPermission(msg); 24 24 + if (permission === null) return false; 25 25 + const check = meta.mode === "any" ? "some" : "every"; 26 26 + return meta.permissions[check]((flag) => permission.has(PermissionFlags[flag])); 27 27 + }; 28 28 + } 29 29 + 30 30 + export function RequireGuild(): Guard { 31 31 + return (msg) => msg.guild !== null; 32 32 + } 33 33 + 34 34 + export function RequireNonBotDecorator(): ClassDecorator { 14 35 return (target) => { 15 36 const guards: Guard[] = Reflect.getMetadata(GUARDS_KEY, target) ?? []; 16 16 - guards.push((msg) => !msg.author.bot); 37 37 + guards.push(RequireNonBot()); 17 38 Reflect.defineMetadata(GUARDS_KEY, guards, target); 18 39 }; 19 40 } 20 41 21 21 - export function RequirePrefix(prefix: string): ClassDecorator { 42 42 + export function RequirePrefixDecorator(prefix: string): ClassDecorator { 43 43 + return (target) => { 44 44 + const guards: Guard[] = Reflect.getMetadata(GUARDS_KEY, target) ?? []; 45 45 + guards.push(RequirePrefix(prefix)); 46 46 + Reflect.defineMetadata(GUARDS_KEY, guards, target); 47 47 + }; 48 48 + } 49 49 + 50 50 + export function RequireUserPermissionDecorator(meta: RequireUserPermissionMeta): ClassDecorator { 22 51 return (target) => { 23 52 const guards: Guard[] = Reflect.getMetadata(GUARDS_KEY, target) ?? []; 24 24 - guards.push((msg) => msg.content.startsWith(prefix)); 53 53 + guards.push(RequireUserPermission(meta)); 25 54 Reflect.defineMetadata(GUARDS_KEY, guards, target); 26 55 }; 27 56 } 28 57 29 29 - export function RequireUserPermission(meta: RequireUserPermissionMeta): ClassDecorator { 58 58 + export function RequireGuildDecorator(): ClassDecorator { 30 59 return (target) => { 31 60 const guards: Guard[] = Reflect.getMetadata(GUARDS_KEY, target) ?? []; 32 32 - const check = meta.mode === "any" ? "some" : "every"; 33 33 - guards.push(async (msg) => { 34 34 - const permission = await GetMemeberPermission(msg); 35 35 - if (permission === null) return false; 36 36 - return meta.permissions[check]((flag) => permission.has(PermissionFlags[flag])); 37 37 - }); 61 61 + guards.push(RequireGuild()); 38 62 Reflect.defineMetadata(GUARDS_KEY, guards, target); 39 63 }; 40 64 }

+1 -1

src/index.ts

··· 1 1 + import "reflect-metadata"; 1 2 import { Bot } from "@/bot"; 2 3 3 3 - // Main entry, while it looks stupidly short, it only takes few lines anyway. 4 4 new Bot().start();

+109 -13

src/registry/commandRegistry.ts

··· 1 1 import type { Message } from "@fluxerjs/core"; 2 2 import { COMMAND_META_KEY, type CommandMeta } from "@/decorators/command"; 3 3 import { GUARDS_KEY, type Guard } from "@/decorators/guards"; 4 4 - import { parseArgs } from "@/args"; 4 4 + import { parseArgs, type ArgSchema } from "@/args"; 5 5 import type { BotContext, ICommand } from "@/types"; 6 6 import type { CommandCtor } from "@/types"; 7 7 import { Logger } from "tslog"; 8 8 + import { MODULE_META_KEY, MODULE_COMMANDS_KEY, type ModuleCommand } from "@/base/ModuleBase"; 8 9 9 10 interface FileRecord { 10 11 filePath: string; 11 12 triggers: string[]; 12 13 } 13 14 15 15 + interface ModuleRecord { 16 16 + name: string; 17 17 + triggers: string[]; 18 18 + instance: object; 19 19 + onUnload?: () => void | Promise<void>; 20 20 + } 21 21 + 14 22 type AnyCommand = ICommand<any>; 15 23 24 24 + interface ModuleEntry { 25 25 + type: "module"; 26 26 + instance: object; 27 27 + methodName: string; 28 28 + args?: ArgSchema; 29 29 + } 30 30 + 31 31 + interface ClassEntry { 32 32 + type: "class"; 33 33 + instance: AnyCommand; 34 34 + args?: ArgSchema; 35 35 + } 36 36 + 37 37 + type Entry = ModuleEntry | ClassEntry; 38 38 + 16 39 export class CommandRegistry { 17 17 - private map = new Map<string, AnyCommand>(); 40 40 + private map = new Map<string, Entry>(); 18 41 private guards = new Map<string, Guard[]>(); 19 42 private fileSources = new Map<string, FileRecord>(); 43 43 + private modules = new Map<string, ModuleRecord>(); 20 44 private logger: Logger<CommandRegistry>; 21 45 22 46 constructor() { ··· 30 54 for (const ctor of ctors) { 31 55 try { 32 56 const meta: CommandMeta = Reflect.getMetadata(COMMAND_META_KEY, ctor); 33 33 - // Checks if command class has @Command decorators 34 57 if (!meta) throw new Error(`${ctor.name} has missing @Command decorators`); 35 58 36 59 const instance = new ctor(); ··· 38 61 const triggers = [meta.name, ...(meta.aliases ?? [])].map((n) => `${prefix}${n}`); 39 62 40 63 for (const trigger of triggers) { 41 41 - this.map.set(trigger, instance); 64 64 + this.map.set(trigger, { type: "class", instance, args: instance.args }); 42 65 this.guards.set(trigger, instanceGuards); 43 66 } 44 67 ··· 52 75 } 53 76 } 54 77 78 78 + registerModule( 79 79 + prefix: string, 80 80 + instance: object, 81 81 + options?: { namespace?: string; guards?: Guard[] }, 82 82 + ): void { 83 83 + const meta = Reflect.getMetadata(MODULE_META_KEY, instance.constructor); 84 84 + if (!meta) { 85 85 + this.logger.error(`${instance.constructor.name} has missing @Module decorator`); 86 86 + return; 87 87 + } 88 88 + 89 89 + const commands: ModuleCommand[] = 90 90 + Reflect.getMetadata(MODULE_COMMANDS_KEY, instance.constructor) ?? []; 91 91 + if (commands.length === 0) { 92 92 + this.logger.warn(`Module ${meta.name} has no commands`); 93 93 + return; 94 94 + } 95 95 + 96 96 + const ns = options?.namespace ?? meta.name; 97 97 + const moduleGuards: Guard[] = options?.guards ?? []; 98 98 + const triggers: string[] = []; 99 99 + 100 100 + for (const cmd of commands) { 101 101 + const commandTriggers = [cmd.meta.name, ...(cmd.meta.aliases ?? [])].map( 102 102 + (n) => `${prefix}${ns}:${n}`, 103 103 + ); 104 104 + triggers.push(...commandTriggers); 105 105 + 106 106 + for (const trigger of commandTriggers) { 107 107 + this.map.set(trigger, { 108 108 + type: "module", 109 109 + instance, 110 110 + methodName: cmd.methodName, 111 111 + args: cmd.meta.args, 112 112 + }); 113 113 + this.guards.set(trigger, [...moduleGuards]); 114 114 + } 115 115 + } 116 116 + 117 117 + this.modules.set(meta.name, { 118 118 + name: meta.name, 119 119 + triggers, 120 120 + instance, 121 121 + onUnload: (instance as { onUnload?: () => void | Promise<void> }).onUnload?.bind(instance), 122 122 + }); 123 123 + 124 124 + (instance as { onLoad?: (registry: CommandRegistry) => void | Promise<void> }).onLoad?.(this); 125 125 + 126 126 + this.logger.info(`Registered module "${meta.name}" with ${commands.length} commands`); 127 127 + } 128 128 + 129 129 + unregisterModule(name: string): void { 130 130 + const record = this.modules.get(name); 131 131 + if (!record) return; 132 132 + 133 133 + for (const trigger of record.triggers) { 134 134 + this.map.delete(trigger); 135 135 + this.guards.delete(trigger); 136 136 + } 137 137 + 138 138 + record.onUnload?.(); 139 139 + this.modules.delete(name); 140 140 + this.logger.info(`Unregistered module "${name}"`); 141 141 + } 142 142 + 55 143 unregisterFile(filePath: string): void { 56 56 - for (const [name, record] of this.fileSources) { 144 144 + for (const [, record] of this.fileSources) { 57 145 if (record.filePath === filePath) { 58 146 for (const trigger of record.triggers) { 59 147 this.map.delete(trigger); 60 148 this.guards.delete(trigger); 61 149 } 62 62 - this.fileSources.delete(name); 150 150 + this.fileSources.delete(record.triggers[0]!); 63 151 } 64 152 } 65 153 } ··· 71 159 const [rawCmd, ...args] = message.content.slice(prefix.length).trim().split(/\s+/); 72 160 const key = `${prefix}${rawCmd?.toLowerCase()}`; 73 161 74 74 - const command = this.map.get(key); 75 75 - if (!command) return; 162 162 + const entry = this.map.get(key); 163 163 + if (!entry) return; 76 164 77 165 const guards = this.guards.get(key) ?? []; 78 166 for (const guard of guards) { 79 167 if (!(await guard(message))) return; 80 168 } 81 169 82 82 - // Parse raw string args through the command's schema if it has one, 83 83 - // otherwise pass the raw array cast to the expected type. 84 84 - const parsedArgs = command.args ? await parseArgs(command.args, args) : ({} as never); 170 170 + const parsedArgs = entry.args ? await parseArgs(entry.args, args) : ({} as never); 85 171 86 172 this.logger.info( 87 87 - `Executing ${rawCmd} ${args ? `with arguments: ${args.join(", ")}` : "without arguments"}`, 173 173 + `Executing ${rawCmd} ${args.length ? `with arguments: ${args.join(", ")}` : "without arguments"}`, 88 174 ); 89 89 - await command.execute(ctx, message, parsedArgs); 175 175 + 176 176 + if (entry.type === "class") { 177 177 + await entry.instance.execute(ctx, message, parsedArgs); 178 178 + } else { 179 179 + const method = (entry.instance as Record<string, unknown>)[entry.methodName]; 180 180 + if (typeof method === "function") { 181 181 + await ( 182 182 + method as (ctx: BotContext, message: Message, args: unknown) => Promise<void> 183 183 + ).call(entry.instance, ctx, message, parsedArgs); 184 184 + } 185 185 + } 90 186 } catch (err) { 91 187 if (err instanceof Error) { 92 188 this.logger.error(`Something went wrong while executing this command: ${err.message}`);

+37

src/registry/loadModules.ts

··· 1 1 + import path from "node:path"; 2 2 + import type { CommandRegistry } from "./commandRegistry"; 3 3 + import { Logger } from "tslog"; 4 4 + import { MODULE_META_KEY } from "@/base/ModuleBase"; 5 5 + 6 6 + const logger = new Logger({ 7 7 + type: "pretty", 8 8 + name: "loadModules", 9 9 + }); 10 10 + 11 11 + export async function loadModules( 12 12 + registry: CommandRegistry, 13 13 + prefix: string, 14 14 + pattern = "src/commands/**/*.ts", 15 15 + options?: { namespace?: string }, 16 16 + ): Promise<void> { 17 17 + const glob = new Bun.Glob(pattern); 18 18 + 19 19 + for await (const file of glob.scan(".")) { 20 20 + const absPath = path.resolve(file); 21 21 + 22 22 + logger.debug(`Loading module from "${absPath}"`); 23 23 + 24 24 + const mod = await import(Bun.pathToFileURL(absPath).href); 25 25 + 26 26 + for (const exported of Object.values(mod)) { 27 27 + if (isModuleCtor(exported)) { 28 28 + const instance = new exported(); 29 29 + registry.registerModule(prefix, instance, options); 30 30 + } 31 31 + } 32 32 + } 33 33 + } 34 34 + 35 35 + function isModuleCtor(val: unknown): val is new () => object { 36 36 + return typeof val === "function" && Reflect.hasMetadata(MODULE_META_KEY, val); 37 37 + }