ReVanced/revanced-bots
1
0
Fork 0
mirror of https://github.com/ReVanced/revanced-bots.git synced 2026-01-11 13:56:15 +00:00
Code Issues Packages Projects Releases Wiki Activity

feat(bots/discord): update to newer command definition framework

Browse Source
This commit is contained in:
PalmDevs
2024-08-13 21:15:34 +07:00
parent 82fac783ea
commit 97f2795df4
15 changed files with 340 additions and 162 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
bots/discord/package.json
View File

@@ -6,12 +6,11 @@
"description": "🤖 Discord bot assisting ReVanced", "description": "🤖 Discord bot assisting ReVanced",
"main": "src/index.ts", "main": "src/index.ts",
"scripts": { "scripts": {
"register": "bun run scripts/reload-slash-commands.ts",
"start": "bun prepare && bun run src/index.ts", "start": "bun prepare && bun run src/index.ts",
"dev": "bun prepare && bun --watch src/index.ts", "dev": "bun prepare && bun --watch src/index.ts",
"build": "bun prepare && bun run scripts/build.ts", "build": "bun prepare && bun run scripts/build.ts",
"watch": "bun dev", "watch": "bun dev",
"prepare": "bun run scripts/generate-indexes.ts && bunx drizzle-kit generate --name=schema" "prepare": "bun run scripts/generate-indexes.ts && bunx --bun drizzle-kit generate --name=schema"
}, },
"repository": { "repository": {
"type": "git", "type": "git",

393
bots/discord/src/classes/Command.ts
View File

@@ -1,76 +1,145 @@
import { ApplicationCommandOptionType } from 'discord.js' import { ApplicationCommandOptionType, ApplicationCommandType } from 'discord.js'
import { isAdmin } from '../utils/discord/permissions'
import { createErrorEmbed } from '$/utils/discord/embeds'
import { isAdmin } from '$/utils/discord/permissions'
import { config } from '../context'
import CommandError, { CommandErrorType } from './CommandError' import CommandError, { CommandErrorType } from './CommandError'
import type { Filter } from 'config.schema'
import type { import type {
APIApplicationCommandChannelOption, APIApplicationCommandChannelOption,
CacheType, CacheType,
Channel, Channel,
ChatInputCommandInteraction, ChatInputCommandInteraction,
CommandInteraction,
CommandInteractionOption, CommandInteractionOption,
GuildMember, GuildMember,
Message, Message,
MessageContextMenuCommandInteraction,
RESTPostAPIApplicationCommandsJSONBody,
RESTPostAPIChatInputApplicationCommandsJSONBody, RESTPostAPIChatInputApplicationCommandsJSONBody,
Role, Role,
User, User,
UserContextMenuCommandInteraction,
UserResolvable,
} from 'discord.js' } from 'discord.js'
import { config } from '../context'
export enum CommandType {
ChatGlobal = 1,
ChatGuild,
ContextMenuUser,
ContextMenuMessage,
ContextMenuGuildMessage,
ContextMenuGuildMember,
}
export default class Command< export default class Command<
Global extends boolean = false, const Type extends CommandType = CommandType.ChatGuild,
Options extends CommandOptionsOptions | undefined = undefined, const Options extends If<IsContextMenu<Type>, undefined, CommandOptionsOptions | undefined> = undefined,
AllowMessageCommand extends boolean = false, const AllowMessageCommand extends If<IsContextMenu<Type>, false, boolean> = false,
> { > {
name: string name: string
description: string description: string
requirements?: CommandRequirements requirements?: CommandRequirements
options?: Options options?: Options
global?: Global type: Type
#execute: CommandExecuteFunction<Global, Options, AllowMessageCommand> allowMessageCommand: AllowMessageCommand
#execute: CommandExecuteFunction<Type, Options, AllowMessageCommand>
static OptionType = ApplicationCommandOptionType static OptionType = ApplicationCommandOptionType
static Type = CommandType
constructor({ constructor({
name, name,
description, description,
requirements, requirements,
options, options,
global, type,
allowMessageCommand,
execute, execute,
}: CommandOptions<Global, Options, AllowMessageCommand>) { }: CommandOptions<Type, Options, AllowMessageCommand>) {
this.name = name this.name = name
this.description = description this.description = description!
this.requirements = requirements this.requirements = requirements
this.options = options this.options = options
this.global = global // @ts-expect-error: Default is `CommandType.GuildOnly`, it makes sense
this.type = type ?? CommandType.ChatGuild
// @ts-expect-error: Default is `false`, it makes sense
this.allowMessageCommand = allowMessageCommand ?? false
this.#execute = execute this.#execute = execute
} }
isGuildSpecific(): this is Command<
CommandType.ChatGuild | CommandType.ContextMenuGuildMember | CommandType.ContextMenuGuildMessage,
Options,
AllowMessageCommand
> {
return [
CommandType.ChatGuild,
CommandType.ContextMenuGuildMessage,
CommandType.ContextMenuGuildMember,
].includes(this.type)
}
isContextMenuSpecific(): this is Command<
| CommandType.ContextMenuGuildMessage
| CommandType.ContextMenuGuildMember
| CommandType.ContextMenuUser
| CommandType.ContextMenuMessage,
undefined,
false
> {
return [
CommandType.ContextMenuMessage,
CommandType.ContextMenuUser,
CommandType.ContextMenuGuildMessage,
CommandType.ContextMenuGuildMember,
].includes(this.type)
}
isGuildContextMenuSpecific(): this is Command<
CommandType.ContextMenuGuildMessage | CommandType.ContextMenuGuildMember,
undefined,
false
> {
return [CommandType.ContextMenuGuildMessage, CommandType.ContextMenuGuildMember].includes(this.type)
}
async onContextMenuInteraction(
context: typeof import('../context'),
interaction: If<
Extends<Type, CommandType.ContextMenuGuildMessage>,
MessageContextMenuCommandInteraction<ToCacheType<Type>>,
UserContextMenuCommandInteraction<ToCacheType<Type>>
>,
): Promise<unknown> {
if (!this.isGuildSpecific() && !interaction.inGuild())
throw new CommandError(CommandErrorType.InteractionNotInGuild)
const executor = await this.#fetchInteractionExecutor(interaction)
const target =
this.type === CommandType.ContextMenuGuildMember
? this.isGuildSpecific()
? fetchMember(interaction as CommandInteraction<'raw' | 'cached'>, interaction.targetId)
: interaction.client.users.fetch(interaction.targetId)
: interaction.channel?.messages.fetch(interaction.targetId)
if (!target) throw new CommandError(CommandErrorType.FetchManagerNotFound)
// @ts-expect-error: Type mismatch (again!) because TypeScript is not smart enough
return await this.#execute({ ...context, executor, target }, interaction, undefined)
}
async onMessage( async onMessage(
context: typeof import('../context'), context: typeof import('../context'),
msg: Message<If<Global, false, true>>, msg: Message<IsGuildSpecific<Type>>,
args: CommandArguments, args: CommandArguments,
): Promise<unknown> { ): Promise<unknown> {
if (!this.global && !msg.inGuild()) if (!this.allowMessageCommand) return
return await msg.reply({ if (!this.isGuildSpecific() && !msg.guildId) throw new CommandError(CommandErrorType.InteractionNotInGuild)
embeds: [createErrorEmbed('Cannot run this command', 'This command can only be used in a server.')],
})
const executor = this.global ? msg.author : await msg.guild?.members.fetch(msg.author.id)! const executor = this.isGuildSpecific()
? await msg.guild?.members.fetch(msg.author)!
if (!(await this.canExecute(executor, msg.channelId))) : await msg.client.users.fetch(msg.author)
return await msg.reply({ if (!(await this.canExecute(executor))) throw new CommandError(CommandErrorType.RequirementsNotMet)
embeds: [
createErrorEmbed(
'Cannot run this command',
'You do not meet the requirements to run this command.',
),
],
})
const options = this.options const options = this.options
? ((await this.#resolveMessageOptions(msg, this.options, args)) as CommandExecuteFunctionOptionsParameter< ? ((await this.#resolveMessageOptions(msg, this.options, args)) as CommandExecuteFunctionOptionsParameter<
@@ -120,14 +189,18 @@ export default class Command<
`Invalid type for argument **${name}**.${argExplainationString}\n\nExpected type: **${expectedType}**\nGot type: **${ApplicationCommandOptionType[arg.type]}**${choicesString}`, `Invalid type for argument **${name}**.${argExplainationString}\n\nExpected type: **${expectedType}**\nGot type: **${ApplicationCommandOptionType[arg.type]}**${choicesString}`,
) )
if ('choices' in option && option.choices && !option.choices.some(({ value }) => value === arg)) const argValue = typeof arg === 'string' ? arg : arg?.id
if (
'choices' in option &&
option.choices &&
!option.choices.some(({ value }) => value === (typeof value === 'number' ? Number(argValue) : argValue))
)
throw new CommandError( throw new CommandError(
CommandErrorType.InvalidArgument, CommandErrorType.InvalidArgument,
`Invalid choice for argument **${name}**.\n${argExplainationString}\n\n${choicesString}\n`, `Invalid choice for argument **${name}**.\n${argExplainationString}${choicesString}\n`,
) )
const argValue = typeof arg === 'string' ? arg : arg?.id
if (argValue && arg) { if (argValue && arg) {
if (isSubcommandLikeOption) { if (isSubcommandLikeOption) {
const [subcommandName, subcommandOption] = iterableOptions.find(([name]) => name === argValue)! const [subcommandName, subcommandOption] = iterableOptions.find(([name]) => name === argValue)!
@@ -142,6 +215,16 @@ export default class Command<
break break
} }
if (
type === ApplicationCommandOptionType.String &&
((typeof option.minLength === 'number' && argValue.length < option.minLength) ||
(typeof option.maxLength === 'number' && argValue.length > option.maxLength))
)
throw new CommandError(
CommandErrorType.InvalidArgument,
`Invalid string length for argument **${name}**.\nLengths allowed: ${option.minLength ?? '(any)'} - ${option.maxLength ?? '(any)'}.${argExplainationString}`,
)
if ( if (
(type === ApplicationCommandOptionType.Channel || (type === ApplicationCommandOptionType.Channel ||
type === ApplicationCommandOptionType.User || type === ApplicationCommandOptionType.User ||
@@ -153,14 +236,21 @@ export default class Command<
`Malformed ID for argument **${name}**.${argExplainationString}`, `Malformed ID for argument **${name}**.${argExplainationString}`,
) )
if ( if (type === ApplicationCommandOptionType.Number || type === ApplicationCommandOptionType.Integer) {
(type === ApplicationCommandOptionType.Number || type === ApplicationCommandOptionType.Integer) && if (Number.isNaN(Number(argValue)))
Number.isNaN(Number(argValue)) throw new CommandError(
) { CommandErrorType.InvalidArgument,
throw new CommandError( `Invalid number for argument **${name}**.${argExplainationString}`,
CommandErrorType.InvalidArgument, )
`Invalid number for argument **${name}**.${argExplainationString}`,
if (
(typeof option.min === 'number' && Number(argValue) < option.min) ||
(typeof option.max === 'number' && Number(argValue) > option.max)
) )
throw new CommandError(
CommandErrorType.InvalidArgument,
`Number out of range for argument **${name}**.\nRange allowed: ${option.min ?? '(any)'} - ${option.max ?? '(any)'}.${argExplainationString}`,
)
} }
if ( if (
@@ -177,7 +267,7 @@ export default class Command<
type === ApplicationCommandOptionType.Number || type === ApplicationCommandOptionType.Integer type === ApplicationCommandOptionType.Number || type === ApplicationCommandOptionType.Integer
? Number(argValue) ? Number(argValue)
: type === ApplicationCommandOptionType.Boolean : type === ApplicationCommandOptionType.Boolean
? argValue[0] === 't' || argValue[0] === 'y' ? ['t', 'y', 'yes', 'true'].some(value => value === argValue.toLowerCase())
: type === ApplicationCommandOptionType.Channel : type === ApplicationCommandOptionType.Channel
? await msg.client.channels.fetch(argValue) ? await msg.client.channels.fetch(argValue)
: type === ApplicationCommandOptionType.User : type === ApplicationCommandOptionType.User
@@ -191,44 +281,27 @@ export default class Command<
return _options return _options
} }
#fetchInteractionExecutor(interaction: CommandInteraction) {
return this.isGuildSpecific()
? fetchMember(interaction as CommandInteraction<'raw' | 'cached'>)
: fetchUser(interaction)
}
async onInteraction( async onInteraction(
context: typeof import('../context'), context: typeof import('../context'),
interaction: ChatInputCommandInteraction, interaction: ChatInputCommandInteraction,
): Promise<unknown> { ): Promise<unknown> {
const { logger } = context if (interaction.commandName !== this.name)
throw new CommandError(
CommandErrorType.InteractionDataMismatch,
'The interaction command name does not match the expected command name.',
)
if (interaction.commandName !== this.name) { if (!this.isGuildSpecific() && !interaction.inGuild())
logger.warn(`Command name mismatch, expected ${this.name}, but got ${interaction.commandName}!`) throw new CommandError(CommandErrorType.InteractionNotInGuild)
return await interaction.reply({
embeds: [
createErrorEmbed(
'Internal command name mismatch',
'The interaction command name does not match the expected command name.',
),
],
})
}
if (!this.global && !interaction.inGuild()) { const executor = await this.#fetchInteractionExecutor(interaction)
logger.error(`Command ${this.name} cannot be run in DMs, but was registered as global`) if (!(await this.canExecute(executor))) throw new CommandError(CommandErrorType.RequirementsNotMet)
return await interaction.reply({
embeds: [createErrorEmbed('Cannot run this command', 'This command can only be used in a server.')],
ephemeral: true,
})
}
const executor = this.global ? interaction.user : await interaction.guild?.members.fetch(interaction.user.id)!
if (!(await this.canExecute(executor, interaction.channelId)))
return await interaction.reply({
embeds: [
createErrorEmbed(
'Cannot run this command',
'You do not meet the requirements to run this command.',
),
],
ephemeral: true,
})
const options = this.options const options = this.options
? ((await this.#resolveInteractionOptions(interaction)) as CommandExecuteFunctionOptionsParameter< ? ((await this.#resolveInteractionOptions(interaction)) as CommandExecuteFunctionOptionsParameter<
@@ -237,14 +310,10 @@ export default class Command<
: undefined : undefined
if (options === null) if (options === null)
return await interaction.reply({ throw new CommandError(
embeds: [ CommandErrorType.InteractionDataMismatch,
createErrorEmbed( 'The registered interaction command option type does not match the expected command option type.',
'Internal command option type mismatch', )
'The interaction command option type does not match the expected command option type.',
),
],
})
// @ts-expect-error: Type mismatch (again!) because TypeScript is not smart enough // @ts-expect-error: Type mismatch (again!) because TypeScript is not smart enough
return await this.#execute({ ...context, executor }, interaction, options) return await this.#execute({ ...context, executor }, interaction, options)
@@ -288,7 +357,7 @@ export default class Command<
return _options return _options
} }
async canExecute(executor: User | GuildMember, channelId: string): Promise<boolean> { async canExecute(executor: User | GuildMember): Promise<boolean> {
if (!this.requirements) return false if (!this.requirements) return false
const isExecutorAdmin = isAdmin(executor) const isExecutorAdmin = isAdmin(executor)
@@ -296,7 +365,6 @@ export default class Command<
const { const {
adminOnly, adminOnly,
channels,
roles, roles,
permissions, permissions,
users, users,
@@ -305,16 +373,23 @@ export default class Command<
memberRequirementsForUsers = 'pass', memberRequirementsForUsers = 'pass',
} = this.requirements } = this.requirements
const member = this.global ? null : (executor as GuildMember) const member = this.isGuildSpecific() ? null : (executor as GuildMember)
const bDefCond = defaultCondition !== 'fail' const boolDefaultCondition = defaultCondition !== 'fail'
const bMemReqForUsers = memberRequirementsForUsers !== 'fail' const boolMemberRequirementsForUsers = memberRequirementsForUsers !== 'fail'
const conditions = [ const conditions = [
adminOnly ? isExecutorAdmin : bDefCond, adminOnly ? isExecutorAdmin : boolDefaultCondition,
channels ? channels.includes(channelId) : bDefCond, users ? users.includes(executor.id) : boolDefaultCondition,
member ? (roles ? roles.some(role => member.roles.cache.has(role)) : bDefCond) : bMemReqForUsers, member
member ? (permissions ? member.permissions.has(permissions) : bDefCond) : bMemReqForUsers, ? roles
users ? users.includes(executor.id) : bDefCond, ? roles.some(role => member.roles.cache.has(role))
: boolDefaultCondition
: boolMemberRequirementsForUsers,
member
? permissions
? member.permissions.has(permissions)
: boolDefaultCondition
: boolMemberRequirementsForUsers,
] ]
if (mode === 'all' && conditions.some(condition => !condition)) return false if (mode === 'all' && conditions.some(condition => !condition)) return false
@@ -323,14 +398,27 @@ export default class Command<
return true return true
} }
get json(): RESTPostAPIChatInputApplicationCommandsJSONBody & { contexts: Array<0 | 1 | 2> } { get json(): RESTPostAPIApplicationCommandsJSONBody {
return { // @ts-expect-error: I hate union types in TypeScript
const base: RESTPostAPIApplicationCommandsJSONBody = {
name: this.name, name: this.name,
type:
this.type === CommandType.ContextMenuGuildMessage || this.type === CommandType.ContextMenuMessage
? ApplicationCommandType.Message
: this.type === CommandType.ContextMenuGuildMember || this.type === CommandType.ContextMenuUser
? ApplicationCommandType.User
: ApplicationCommandType.ChatInput,
}
if (this.isContextMenuSpecific()) return base
return {
...base,
description: this.description, description: this.description,
options: this.options ? this.#transformOptions(this.options) : undefined, options: this.options ? this.#transformOptions(this.options) : undefined,
// https://discord.com/developers/docs/interactions/receiving-and-responding#interaction-object-interaction-context-types // https://discord.com/developers/docs/interactions/receiving-and-responding#interaction-object-interaction-context-types
contexts: this.global ? [0] : [0, 1], contexts: this.isGuildSpecific() ? [0] : [0, 1, 2],
} } as RESTPostAPIChatInputApplicationCommandsJSONBody & { contexts: Array<0 | 1 | 2> }
} }
#transformOptions(optionsObject: Record<string, CommandOption>) { #transformOptions(optionsObject: Record<string, CommandOption>) {
@@ -377,8 +465,8 @@ export default class Command<
export class ModerationCommand< export class ModerationCommand<
Options extends CommandOptionsOptions, Options extends CommandOptionsOptions,
AllowMessageCommand extends boolean = true, AllowMessageCommand extends boolean = true,
> extends Command<false, Options, AllowMessageCommand> { > extends Command<CommandType.ChatGuild, Options, AllowMessageCommand> {
constructor(options: ExtendedCommandOptions<false, Options, AllowMessageCommand>) { constructor(options: ExtendedCommandOptions<CommandType.ChatGuild, Options, AllowMessageCommand>) {
super({ super({
...options, ...options,
requirements: { requirements: {
@@ -388,17 +476,16 @@ export class ModerationCommand<
}, },
// @ts-expect-error: No thanks // @ts-expect-error: No thanks
allowMessageCommand: options.allowMessageCommand ?? true, allowMessageCommand: options.allowMessageCommand ?? true,
global: false, type: CommandType.ChatGuild,
}) })
} }
} }
export class AdminCommand<Options extends CommandOptionsOptions, AllowMessageCommand extends boolean> extends Command< export class AdminCommand<
true, Options extends CommandOptionsOptions,
Options, AllowMessageCommand extends boolean = true,
AllowMessageCommand > extends Command<CommandType.ChatGlobal, Options, AllowMessageCommand> {
> { constructor(options: ExtendedCommandOptions<CommandType.ChatGlobal, Options, AllowMessageCommand>) {
constructor(options: ExtendedCommandOptions<true, Options, AllowMessageCommand>) {
super({ super({
...options, ...options,
requirements: { requirements: {
@@ -406,38 +493,52 @@ export class AdminCommand<Options extends CommandOptionsOptions, AllowMessageCom
adminOnly: true, adminOnly: true,
defaultCondition: 'pass', defaultCondition: 'pass',
}, },
global: true, allowMessageCommand: options.allowMessageCommand ?? (true as AllowMessageCommand),
type: CommandType.ChatGlobal,
}) })
} }
} }
const fetchMember = async (
interaction: CommandInteraction<'raw' | 'cached'>,
source: UserResolvable = interaction.user,
manager = interaction.guild?.members,
) => {
const _manager = manager ?? (await interaction.client.guilds.fetch(interaction.guildId).then(it => it.members))
if (!_manager) throw new CommandError(CommandErrorType.FetchManagerNotFound, 'Cannot fetch member.')
return await _manager.fetch(source)
}
const fetchUser = (interaction: CommandInteraction, source: UserResolvable = interaction.user) => {
return interaction.client.users.fetch(source)
}
/* TODO: /* TODO:
APIApplicationCommandAttachmentOption APIApplicationCommandAttachmentOption
APIApplicationCommandMentionableOption APIApplicationCommandMentionableOption
APIApplicationCommandRoleOption APIApplicationCommandRoleOption
*/ */
export interface CommandOptions< export type CommandOptions<
Global extends boolean, Type extends CommandType,
Options extends CommandOptionsOptions | undefined, Options extends CommandOptionsOptions | undefined,
AllowMessageCommand extends boolean, AllowMessageCommand extends boolean,
> { > = {
name: string name: string
description: string
requirements?: CommandRequirements requirements?: CommandRequirements
options?: Options options?: Options
execute: CommandExecuteFunction<Global, Options, AllowMessageCommand> execute: CommandExecuteFunction<Type, Options, AllowMessageCommand>
global?: Global type?: Type
allowMessageCommand?: AllowMessageCommand allowMessageCommand?: AllowMessageCommand
} } & If<IsContextMenu<Type>, { description?: never }, { description: string }>
export type CommandArguments = Array<string | CommandSpecialArgument> export type CommandArguments = Array<string | CommandSpecialArgument>
export type CommandSpecialArgument = { export type CommandSpecialArgument = {
type: (typeof CommandSpecialArgumentType)[keyof typeof CommandSpecialArgumentType] type: (typeof CommandSpecialArgumentType)[keyof typeof CommandSpecialArgumentType]
id: string id: string
} }
//! If things ever get minified, this will most likely break property access via string names
export const CommandSpecialArgumentType = { export const CommandSpecialArgumentType = {
Channel: ApplicationCommandOptionType.Channel, Channel: ApplicationCommandOptionType.Channel,
Role: ApplicationCommandOptionType.Role, Role: ApplicationCommandOptionType.Role,
@@ -445,31 +546,56 @@ export const CommandSpecialArgumentType = {
} }
type ExtendedCommandOptions< type ExtendedCommandOptions<
Global extends boolean, Type extends CommandType,
Options extends CommandOptionsOptions, Options extends CommandOptionsOptions,
AllowMessageCommand extends boolean, AllowMessageCommand extends boolean,
> = Omit<CommandOptions<Global, Options, AllowMessageCommand>, 'global'> & { > = Omit<CommandOptions<Type, Options, AllowMessageCommand>, 'type'> & {
requirements?: Omit<CommandOptions<false, Options, AllowMessageCommand>['requirements'], 'defaultCondition'> requirements?: Omit<CommandOptions<Type, Options, AllowMessageCommand>['requirements'], 'defaultCondition'>
} }
export type CommandOptionsOptions = Record<string, CommandOption> export type CommandOptionsOptions = Record<string, CommandOption>
type ToCacheType<Type extends CommandType> = If<IsGuildSpecific<Type>, 'raw' | 'cached', CacheType>
type CommandExecuteFunction< type CommandExecuteFunction<
Global extends boolean, Type extends CommandType,
Options extends CommandOptionsOptions | undefined, Options extends CommandOptionsOptions | undefined,
AllowMessageCommand extends boolean, AllowMessageCommand extends boolean,
> = ( > = (
context: CommandContext<Global>, context: CommandContext<Type>,
trigger: If< trigger: If<
AllowMessageCommand, AllowMessageCommand,
Message<InvertBoolean<Global>> | ChatInputCommandInteraction<If<Global, CacheType, 'raw' | 'cached'>>, Message<IsGuildSpecific<Type>> | CommandTypeToInteractionMap<ToCacheType<Type>>[Type],
ChatInputCommandInteraction<If<Global, CacheType, 'raw' | 'cached'>> CommandTypeToInteractionMap<ToCacheType<Type>>[Type]
>, >,
options: Options extends CommandOptionsOptions ? CommandExecuteFunctionOptionsParameter<Options> : never, options: Options extends CommandOptionsOptions ? CommandExecuteFunctionOptionsParameter<Options> : never,
) => Promise<unknown> | unknown ) => Promise<unknown> | unknown
type CommandTypeToInteractionMap<CT extends CacheType> = {
[CommandType.ChatGlobal]: ChatInputCommandInteraction<CT>
[CommandType.ChatGuild]: ChatInputCommandInteraction<CT>
[CommandType.ContextMenuUser]: UserContextMenuCommandInteraction<CT>
[CommandType.ContextMenuMessage]: MessageContextMenuCommandInteraction<CT>
[CommandType.ContextMenuGuildMessage]: MessageContextMenuCommandInteraction<CT>
[CommandType.ContextMenuGuildMember]: MessageContextMenuCommandInteraction<CT>
}
type IsContextMenu<Type extends CommandType> = Extends<
Type,
| CommandType.ContextMenuGuildMessage
| CommandType.ContextMenuGuildMember
| CommandType.ContextMenuMessage
| CommandType.ContextMenuUser
>
type IsGuildSpecific<Type extends CommandType> = Extends<
Type,
CommandType.ChatGuild | CommandType.ContextMenuGuildMember | CommandType.ContextMenuGuildMessage
>
type Extends<T, U> = T extends U ? true : false
type If<T extends boolean | undefined, U, V> = T extends true ? U : V type If<T extends boolean | undefined, U, V> = T extends true ? U : V
type InvertBoolean<T extends boolean> = If<T, false, true> // type InvertBoolean<T extends boolean> = If<T, false, true>
type CommandExecuteFunctionOptionsParameter<Options extends CommandOptionsOptions> = { type CommandExecuteFunctionOptionsParameter<Options extends CommandOptionsOptions> = {
[K in keyof Options]: Options[K]['type'] extends [K in keyof Options]: Options[K]['type'] extends
@@ -484,8 +610,13 @@ type CommandExecuteFunctionOptionsParameter<Options extends CommandOptionsOption
> >
} }
type CommandContext<Global extends boolean> = typeof import('../context') & { type CommandContext<Type extends CommandType> = typeof import('../context') & {
executor: CommandExecutor<Global> executor: CommandExecutor<Type>
target: If<
Extends<Type, CommandType.ContextMenuGuildMember>,
GuildMember,
If<Extends<Type, CommandType.ContextMenuGuildMessage>, Message<true>, never>
>
} }
type CommandOptionValueMap = { type CommandOptionValueMap = {
@@ -511,7 +642,7 @@ type CommandOption =
| CommandSubcommandOption | CommandSubcommandOption
| CommandSubcommandGroupOption | CommandSubcommandGroupOption
type CommandExecutor<Global extends boolean> = If<Global, User, GuildMember> type CommandExecutor<Type extends CommandType> = If<IsGuildSpecific<Type>, GuildMember, User>
type CommandOptionBase<Type extends ApplicationCommandOptionType> = { type CommandOptionBase<Type extends ApplicationCommandOptionType> = {
type: Type type: Type
@@ -585,10 +716,12 @@ interface CommandSubcommandLikeOption<
type CommandSubcommandOption = CommandSubcommandLikeOption<ApplicationCommandOptionType.Subcommand> type CommandSubcommandOption = CommandSubcommandLikeOption<ApplicationCommandOptionType.Subcommand>
type CommandSubcommandGroupOption = CommandSubcommandLikeOption<ApplicationCommandOptionType.SubcommandGroup> type CommandSubcommandGroupOption = CommandSubcommandLikeOption<ApplicationCommandOptionType.SubcommandGroup>
export type CommandRequirements = Filter & { export type CommandRequirements = {
mode?: 'all' | 'any' users?: string[]
adminOnly?: boolean roles?: string[]
permissions?: bigint permissions?: bigint
adminOnly?: boolean
defaultCondition?: 'fail' | 'pass' defaultCondition?: 'fail' | 'pass'
memberRequirementsForUsers?: 'pass' | 'fail' memberRequirementsForUsers?: 'fail' | 'pass'
mode?: 'all' | 'any'
} }

33
bots/discord/src/classes/CommandError.ts
View File

@@ -1,9 +1,9 @@
import { createErrorEmbed } from '$/utils/discord/embeds' import { createErrorEmbed } from '../utils/discord/embeds'
export default class CommandError extends Error { export default class CommandError extends Error {
type: CommandErrorType type: CommandErrorType
constructor(type: CommandErrorType, message?: string) { constructor(type: CommandErrorType, message: string = ErrorMessageMap[type]) {
super(message) super(message)
this.name = 'CommandError' this.name = 'CommandError'
this.type = type this.type = type
@@ -15,19 +15,34 @@ export default class CommandError extends Error {
} }
export enum CommandErrorType { export enum CommandErrorType {
Generic, Generic = 1,
InteractionNotInGuild,
InteractionDataMismatch,
FetchManagerNotFound,
FetchNotFound,
RequirementsNotMet = 100,
MissingArgument, MissingArgument,
InvalidArgument, InvalidArgument,
InvalidUser,
InvalidChannel,
InvalidDuration,
} }
const ErrorTitleMap: Record<CommandErrorType, string> = { const ErrorTitleMap: Record<CommandErrorType, string> = {
[CommandErrorType.Generic]: 'An exception was thrown', [CommandErrorType.Generic]: 'An exception was thrown',
[CommandErrorType.InteractionNotInGuild]: 'This command can only be used in servers',
[CommandErrorType.InteractionDataMismatch]: 'Command data mismatch',
[CommandErrorType.FetchManagerNotFound]: 'Cannot fetch data (manager not found)',
[CommandErrorType.FetchNotFound]: 'Cannot fetch data (source not found)',
[CommandErrorType.RequirementsNotMet]: 'Command requirements not met',
[CommandErrorType.MissingArgument]: 'Missing argument', [CommandErrorType.MissingArgument]: 'Missing argument',
[CommandErrorType.InvalidArgument]: 'Invalid argument', [CommandErrorType.InvalidArgument]: 'Invalid argument',
[CommandErrorType.InvalidUser]: 'Invalid user', }
[CommandErrorType.InvalidChannel]: 'Invalid channel',
[CommandErrorType.InvalidDuration]: 'Invalid duration', const ErrorMessageMap: Record<CommandErrorType, string> = {
[CommandErrorType.Generic]: 'An generic exception was thrown.',
[CommandErrorType.InteractionNotInGuild]: 'This command can only be used in servers.',
[CommandErrorType.InteractionDataMismatch]: 'Interaction command data does not match the expected command data.',
[CommandErrorType.FetchManagerNotFound]: 'Cannot fetch required data.',
[CommandErrorType.FetchNotFound]: 'Cannot fetch target.',
[CommandErrorType.RequirementsNotMet]: 'You do not meet the requirements to use this command.',
[CommandErrorType.MissingArgument]: 'You are missing a required argument.',
[CommandErrorType.InvalidArgument]: 'You provided an invalid argument.',
} }

2
bots/discord/src/commands/admin/slash-commands.ts
View File

@@ -42,7 +42,7 @@ export default new AdminCommand({
const { global: globalCommands, guild: guildCommands } = Object.groupBy( const { global: globalCommands, guild: guildCommands } = Object.groupBy(
Object.values(context.discord.commands), Object.values(context.discord.commands),
cmd => (cmd.global ? 'global' : 'guild'), cmd => (cmd.isGuildSpecific() ? 'guild' : 'global'),
) )
const { const {

2
bots/discord/src/commands/fun/coinflip.ts
View File

@@ -6,7 +6,7 @@ import { applyCommonEmbedStyles } from '$/utils/discord/embeds'
export default new Command({ export default new Command({
name: 'coinflip', name: 'coinflip',
description: 'Do a coinflip!', description: 'Do a coinflip!',
global: true, type: Command.Type.ChatGlobal,
requirements: { requirements: {
defaultCondition: 'pass', defaultCondition: 'pass',
}, },

2
bots/discord/src/commands/moderation/ban.ts
View File

@@ -35,7 +35,7 @@ export default new ModerationCommand({
if (moderator.roles.highest.comparePositionTo(member.roles.highest) <= 0) if (moderator.roles.highest.comparePositionTo(member.roles.highest) <= 0)
throw new CommandError( throw new CommandError(
CommandErrorType.InvalidUser, CommandErrorType.InvalidArgument,
'You cannot ban a user with a role equal to or higher than yours.', 'You cannot ban a user with a role equal to or higher than yours.',
) )
} }

6
bots/discord/src/commands/moderation/mute.ts
View File

@@ -37,14 +37,14 @@ export default new ModerationCommand({
if (Number.isInteger(duration) && duration! < 1) if (Number.isInteger(duration) && duration! < 1)
throw new CommandError( throw new CommandError(
CommandErrorType.InvalidDuration, CommandErrorType.InvalidArgument,
'The duration must be at least 1 millisecond long.', 'The duration must be at least 1 millisecond long.',
) )
const expires = Math.max(duration, Date.now() + duration) const expires = Math.max(duration, Date.now() + duration)
if (!member) if (!member)
throw new CommandError( throw new CommandError(
CommandErrorType.InvalidUser, CommandErrorType.InvalidArgument,
'The provided member is not in the server or does not exist.', 'The provided member is not in the server or does not exist.',
) )
@@ -53,7 +53,7 @@ export default new ModerationCommand({
if (moderator.roles.highest.comparePositionTo(member.roles.highest) <= 0) if (moderator.roles.highest.comparePositionTo(member.roles.highest) <= 0)
throw new CommandError( throw new CommandError(
CommandErrorType.InvalidUser, CommandErrorType.InvalidArgument,
'You cannot mute a user with a role equal to or higher than yours.', 'You cannot mute a user with a role equal to or higher than yours.',
) )

2
bots/discord/src/commands/moderation/purge.ts
View File

@@ -32,7 +32,7 @@ export default new ModerationCommand({
const channel = interaction.channel! const channel = interaction.channel!
if (!channel.isTextBased()) if (!channel.isTextBased())
throw new CommandError(CommandErrorType.InvalidChannel, 'The supplied channel is not a text channel.') throw new CommandError(CommandErrorType.InvalidArgument, 'The supplied channel is not a text channel.')
const embed = applyCommonEmbedStyles( const embed = applyCommonEmbedStyles(
new EmbedBuilder({ new EmbedBuilder({

6
bots/discord/src/commands/moderation/role-preset.ts
View File

@@ -45,7 +45,7 @@ export default new ModerationCommand({
if (!member) if (!member)
throw new CommandError( throw new CommandError(
CommandErrorType.InvalidUser, CommandErrorType.InvalidArgument,
'The provided member is not in the server or does not exist.', 'The provided member is not in the server or does not exist.',
) )
@@ -56,13 +56,13 @@ export default new ModerationCommand({
const duration = durationInput ? parseDuration(durationInput) : Infinity const duration = durationInput ? parseDuration(durationInput) : Infinity
if (Number.isInteger(duration) && duration! < 1) if (Number.isInteger(duration) && duration! < 1)
throw new CommandError( throw new CommandError(
CommandErrorType.InvalidDuration, CommandErrorType.InvalidArgument,
'The duration must be at least 1 millisecond long.', 'The duration must be at least 1 millisecond long.',
) )
if (moderator.roles.highest.comparePositionTo(member.roles.highest) <= 0) if (moderator.roles.highest.comparePositionTo(member.roles.highest) <= 0)
throw new CommandError( throw new CommandError(
CommandErrorType.InvalidUser, CommandErrorType.InvalidArgument,
'You cannot apply a role preset to a user with a role equal to or higher than yours.', 'You cannot apply a role preset to a user with a role equal to or higher than yours.',
) )

6
bots/discord/src/commands/moderation/slowmode.ts
View File

@@ -27,14 +27,14 @@ export default new ModerationCommand({
if (!channel?.isTextBased() || channel.isDMBased()) if (!channel?.isTextBased() || channel.isDMBased())
throw new CommandError( throw new CommandError(
CommandErrorType.InvalidChannel, CommandErrorType.InvalidArgument,
'The supplied channel is not a text channel.', 'The supplied channel is not a text channel.',
) )
if (Number.isNaN(duration)) throw new CommandError(CommandErrorType.InvalidDuration, 'Invalid duration.') if (Number.isNaN(duration)) throw new CommandError(CommandErrorType.InvalidArgument, 'Invalid duration.')
if (duration < 0 || duration > 36e4) if (duration < 0 || duration > 36e4)
throw new CommandError( throw new CommandError(
CommandErrorType.InvalidDuration, CommandErrorType.InvalidArgument,
'Duration out of range, must be between 0s and 6h.', 'Duration out of range, must be between 0s and 6h.',
) )

2
bots/discord/src/commands/moderation/unmute.ts
View File

@@ -20,7 +20,7 @@ export default new ModerationCommand({
const member = await interaction.guild!.members.fetch(user.id) const member = await interaction.guild!.members.fetch(user.id)
if (!member) if (!member)
throw new CommandError( throw new CommandError(
CommandErrorType.InvalidUser, CommandErrorType.InvalidArgument,
'The provided member is not in the server or does not exist.', 'The provided member is not in the server or does not exist.',
) )

4
bots/discord/src/context.ts
View File

@@ -17,7 +17,7 @@ export const logger = createLogger({
import * as commands from './commands' import * as commands from './commands'
import * as schemas from './database/schemas' import * as schemas from './database/schemas'
import type { default as Command, CommandOptionsOptions } from './classes/Command' import type { default as Command, CommandOptionsOptions, CommandType } from './classes/Command'
export const api = { export const api = {
client: new APIClient({ client: new APIClient({
@@ -83,7 +83,7 @@ export const discord = {
}), }),
commands: Object.fromEntries(Object.values(commands).map(cmd => [cmd.name, cmd])) as Record< commands: Object.fromEntries(Object.values(commands).map(cmd => [cmd.name, cmd])) as Record<
string, string,
Command<boolean, CommandOptionsOptions | undefined, boolean> Command<CommandType, CommandOptionsOptions | undefined, boolean>
>, >,
stickyMessages: {} as Record< stickyMessages: {} as Record<
string, string,

11
bots/discord/src/events/discord/interactionCreate/chatCommand.ts
View File

@@ -8,19 +8,24 @@ withContext(on, 'interactionCreate', async (context, interaction) => {
const { logger, discord } = context const { logger, discord } = context
const command = discord.commands[interaction.commandName] const command = discord.commands[interaction.commandName]
logger.debug(`Command ${interaction.commandName} being invoked by ${interaction.user.tag}`) logger.debug(`Command ${interaction.commandName} being invoked by ${interaction.user.tag} via chat`)
if (!command) if (!command)
return void logger.error(`Interaction command ${interaction.commandName} not implemented but registered!!!`) return void logger.error(`Chat command ${interaction.commandName} not implemented but registered!!!`)
try { try {
logger.debug(`Command ${interaction.commandName} being executed`) logger.debug(`Command ${interaction.commandName} being executed via chat`)
await command.onInteraction(context, interaction) await command.onInteraction(context, interaction)
} catch (err) { } catch (err) {
if (!(err instanceof CommandError)) if (!(err instanceof CommandError))
logger.error(`Error while executing command ${interaction.commandName}:`, err) logger.error(`Error while executing command ${interaction.commandName}:`, err)
await interaction[interaction.replied ? 'followUp' : 'reply']({ await interaction[interaction.replied ? 'followUp' : 'reply']({
embeds: [err instanceof CommandError ? err.toEmbed() : createStackTraceEmbed(err)], embeds: [err instanceof CommandError ? err.toEmbed() : createStackTraceEmbed(err)],
ephemeral: true, ephemeral: true,
}) })
// 100 and up are user errors
if (err instanceof CommandError && err.type < 100)
logger.error(`Command ${interaction.commandName} internally failed with error:`, err)
} }
}) })

26
bots/discord/src/events/discord/interactionCreate/contextMenuCommand.ts Normal file
View File

@@ -0,0 +1,26 @@
import CommandError from '$/classes/CommandError'
import { createStackTraceEmbed } from '$utils/discord/embeds'
import { on, withContext } from '$utils/discord/events'
withContext(on, 'interactionCreate', async (context, interaction) => {
if (!interaction.isContextMenuCommand()) return
const { logger, discord } = context
const command = discord.commands[interaction.commandName]
logger.debug(`Command ${interaction.commandName} being invoked by ${interaction.user.tag} via context menu`)
if (!command)
return void logger.error(`Context menu command ${interaction.commandName} not implemented but registered!!!`)
try {
logger.debug(`Command ${interaction.commandName} being executed via context menu`)
await command.onContextMenuInteraction(context, interaction)
} catch (err) {
if (!(err instanceof CommandError))
logger.error(`Error while executing command ${interaction.commandName}:`, err)
await interaction[interaction.replied ? 'followUp' : 'reply']({
embeds: [err instanceof CommandError ? err.toEmbed() : createStackTraceEmbed(err)],
ephemeral: true,
})
}
})

4
bots/discord/src/events/discord/messageCreate/messageCommand.ts
View File

@@ -18,7 +18,7 @@ withContext(on, 'messageCreate', async (context, msg) => {
if (!commandName) return if (!commandName) return
const command = discord.commands[commandName] const command = discord.commands[commandName]
logger.debug(`Command ${commandName} being invoked by ${msg.author.id}`) logger.debug(`Command ${commandName} being invoked by ${msg.author.id} via message`)
if (!command) return void logger.debug(`Message command ${commandName} not implemented`) if (!command) return void logger.debug(`Message command ${commandName} not implemented`)
const argsRegex: RegExp = /[^\s"]+|"([^"]*)"/g const argsRegex: RegExp = /[^\s"]+|"([^"]*)"/g
@@ -46,7 +46,7 @@ withContext(on, 'messageCreate', async (context, msg) => {
} }
try { try {
logger.debug(`Command ${commandName} being executed`) logger.debug(`Command ${commandName} being executed via message`)
await command.onMessage(context, msg, args) await command.onMessage(context, msg, args)
} catch (err) { } catch (err) {
if (!(err instanceof CommandError)) logger.error(`Error while executing command ${commandName}:`, err) if (!(err instanceof CommandError)) logger.error(`Error while executing command ${commandName}:`, err)