feat: argument handling

Author: davidabou

src/commands.ts

@@ -9,22 +9,20 @@ import {
   type Harmonix,
   type HarmonixCommand,
   type HarmonixCommandInput,
-  type CommandArg,
-  type CommandExecuteOptions,
-  ArgumentResolver
+  type CommandArg
 } from './types'
 import { SlashCommandBuilder } from 'discord.js'
 
 export const resolveHarmonixCommand = (
   cmd: HarmonixCommandInput,
   harmonixOptions: Harmonix['options']
-): HarmonixCommand<boolean> => {
+): HarmonixCommand<boolean, CommandArg[]> => {
   if (typeof cmd === 'string') {
     const _jiti = jiti(harmonixOptions.rootDir, {
       interopDefault: true
     })
     const _cmdPath = _jiti.resolve(cmd)
-    const command = _jiti(_cmdPath) as HarmonixCommand<boolean>
+    const command = _jiti(_cmdPath) as HarmonixCommand<boolean, CommandArg[]>
     const options: CommandOptions = {
       name: command.options.name || filename(_cmdPath).split('.')[0],
       category: command.options.category || filename(dirname(_cmdPath)),
@@ -38,14 +36,14 @@ export const resolveHarmonixCommand = (
   }
 }
 
-export const defineCommand = <Slash extends boolean>(
-  options: CommandOptions & { slash?: Slash },
-  execute: CommandExecute<Slash>
-): HarmonixCommand<Slash> => {
+export const defineCommand = <Slash extends boolean, Args extends CommandArg[]>(
+  options: CommandOptions & { slash?: Slash; args?: Args },
+  execute: CommandExecute<Slash, Args>
+): HarmonixCommand<Slash, Args> => {
   return { options, execute }
 }
 
-export const toJSON = (cmd: HarmonixCommand<true>) => {
+export const toJSON = (cmd: HarmonixCommand<true, CommandArg[]>) => {
   const builder = new SlashCommandBuilder()
     .setName(cmd.options.name!)
     .setDescription(cmd.options.description || 'No description provided')
@@ -101,14 +99,6 @@ export const toJSON = (cmd: HarmonixCommand<true>) => {
               .setRequired(arg.required!)
           )
           break
-        case CommandArgType.Mentionable:
-          builder.addMentionableOption((opt) =>
-            opt
-              .setName(arg.name)
-              .setDescription(arg.description)
-              .setRequired(arg.required!)
-          )
-          break
         case CommandArgType.Number:
           builder.addNumberOption((opt) =>
             opt
@@ -117,14 +107,6 @@ export const toJSON = (cmd: HarmonixCommand<true>) => {
               .setRequired(arg.required!)
           )
           break
-        case CommandArgType.Attachment:
-          builder.addAttachmentOption((opt) =>
-            opt
-              .setName(arg.name)
-              .setDescription(arg.description)
-              .setRequired(arg.required!)
-          )
-          break
       }
     }
   }
@@ -147,21 +129,3 @@ export const defineArgument = <
     required: options.required ?? true
   } as CommandArg
 }
-
-export const useArguments = (
-  options: CommandExecuteOptions
-): ArgumentResolver => {
-  if (options.slash) {
-    return {
-      get: (name: string) => {
-        return options.params.get(name)
-      }
-    }
-  } else {
-    return {
-      get: (name: string) => {
-        return options.params[name] || undefined
-      }
-    }
-  }
-}

src/discord.ts

@@ -1,5 +1,19 @@
-import { Client, REST, Routes, Events } from 'discord.js'
-import type { Harmonix, HarmonixCommand, HarmonixEvent } from './types'
+import {
+  Client,
+  REST,
+  Routes,
+  Events,
+  type User,
+  ApplicationCommandOptionType
+} from 'discord.js'
+import {
+  type CommandArg,
+  CommandArgType,
+  type Harmonix,
+  type HarmonixCommand,
+  type HarmonixEvent,
+  type MessageOrInteraction
+} from './types'
 import 'dotenv/config'
 import { toJSON } from './commands'
 
@@ -13,48 +27,64 @@ export const initCient = (harmonixOptions: Harmonix['options']) => {
 
 export const registerCommands = (
   harmonix: Harmonix,
-  commands: HarmonixCommand<false>[]
+  commands: HarmonixCommand<false, CommandArg[]>[]
 ) => {
-  harmonix.client?.on(Events.MessageCreate, (message) => {
+  harmonix.client?.on(Events.MessageCreate, async (message) => {
     if (message.author.bot) return
     const prefix = harmonix.options.defaultPrefix
     const args = message.content.slice(prefix.length).trim().split(/ +/)
     const command = args.shift()?.toLowerCase()
 
     if (!command) return
     const cmd = commands.find((cmd) => cmd.options.name === command)
-
-    const params = Object.fromEntries(
-      cmd?.options.args?.map((arg, i) => [arg.name, args[i]]) || []
+    const resolvedArgs = await Promise.all(
+      (cmd?.options.args || []).map(async (arg, i) => [
+        arg.name,
+        await resolveArgument(message, arg.type, args[i])
+      ])
     )
+    const fullArgs = Object.fromEntries(resolvedArgs)
+
     if (!cmd || cmd.options.slash) return
-    cmd.execute(harmonix.client!, message, { slash: false, params: params })
+    cmd.execute(harmonix.client!, message, { slash: false, args: fullArgs })
   })
 }
 
 export const registerSlashCommands = async (
   harmonix: Harmonix,
-  commands: HarmonixCommand<true>[]
+  commands: HarmonixCommand<true, CommandArg[]>[]
 ) => {
   if (commands.length === 0) return
-  const rest = new REST().setToken(process.env.HARMONIX_CLIENT_TOKEN || '')
+  const rest = new REST().setToken(process.env.HARMONIX_CLIENT_TOKEN!)
 
   await rest.put(
     Routes.applicationCommands(
-      harmonix.options.clientId || process.env.HARMONIX_CLIENT_ID || ''
+      harmonix.options.clientId || process.env.HARMONIX_CLIENT_ID!
     ),
     { body: commands.map((cmd) => toJSON(cmd)) }
   )
-  harmonix.client?.on('interactionCreate', (interaction) => {
+  harmonix.client?.on('interactionCreate', async (interaction) => {
     if (!interaction.isChatInputCommand()) return
     const cmd = commands.find(
       (cmd) => cmd.options.name === interaction.commandName
     )
 
     if (!cmd || !cmd.options.slash) return
+    const resolvedArgs = await Promise.all(
+      interaction.options.data.map(async (opt) => [
+        opt.name,
+        await resolveArgument(
+          interaction,
+          commandArgType(opt.type)!,
+          String(opt.value)
+        )
+      ])
+    )
+    const fullArgs = Object.fromEntries(resolvedArgs)
+
     cmd.execute(harmonix.client!, interaction, {
       slash: true,
-      params: interaction.options
+      args: fullArgs
     })
   })
 }
@@ -68,3 +98,81 @@ export const registerEvents = (harmonix: Harmonix, events: HarmonixEvent[]) => {
     }
   }
 }
+
+export const resolveArgument = async (
+  entity: MessageOrInteraction,
+  type: CommandArgType,
+  value: string
+) => {
+  switch (type) {
+    case CommandArgType.String:
+      return value
+    case CommandArgType.Integer:
+      return parseInt(value)
+    case CommandArgType.Boolean:
+      return value === 'true'
+    case CommandArgType.User:
+      const user = await resolveUser(entity, value)
+
+      return user
+    case CommandArgType.Channel:
+      const channel = await resolveChannel(entity, value)
+
+      return channel
+    case CommandArgType.Role:
+      const role = await resolveRole(entity, value)
+
+      return role
+    case CommandArgType.Number:
+      return parseFloat(value)
+  }
+}
+
+const resolveUser = async (
+  entity: MessageOrInteraction,
+  value: string
+): Promise<User | undefined> => {
+  return entity.guild?.members.cache.find(
+    (member) =>
+      member.user.username === value ||
+      member.nickname === value ||
+      member.id === value ||
+      value == `<@${member.id}>` ||
+      value == `<@!${member.id}>`
+  )?.user
+}
+
+const resolveChannel = async (entity: MessageOrInteraction, value: string) => {
+  return entity.guild?.channels.cache.find(
+    (channel) =>
+      channel.name === value ||
+      channel.id === value ||
+      value == `<#${channel.id}>`
+  )
+}
+
+const resolveRole = async (entity: MessageOrInteraction, value: string) => {
+  return entity.guild?.roles.cache.find(
+    (role) =>
+      role.name === value || role.id === value || value == `<@&${role.id}>`
+  )
+}
+
+const commandArgType = (type: ApplicationCommandOptionType) => {
+  switch (type) {
+    case ApplicationCommandOptionType.String:
+      return CommandArgType.String
+    case ApplicationCommandOptionType.Integer:
+      return CommandArgType.Integer
+    case ApplicationCommandOptionType.Boolean:
+      return CommandArgType.Boolean
+    case ApplicationCommandOptionType.User:
+      return CommandArgType.User
+    case ApplicationCommandOptionType.Channel:
+      return CommandArgType.Channel
+    case ApplicationCommandOptionType.Role:
+      return CommandArgType.Role
+    case ApplicationCommandOptionType.Number:
+      return CommandArgType.Number
+  }
+}

src/types/commands.ts

@@ -1,4 +1,4 @@
-import {
+import type {
   Client,
   Message,
   ChatInputCommandInteraction,
@@ -12,9 +12,7 @@ export enum CommandArgType {
   User = 'User',
   Channel = 'Channel',
   Role = 'Role',
-  Mentionable = 'Mentionable',
-  Number = 'Number',
-  Attachment = 'Attachment'
+  Number = 'Number'
 }
 
 export interface HarmonixCommandArgType {
@@ -46,28 +44,19 @@ export type ExecuteArgument<Slash extends boolean> = Slash extends true
     ? Message
     : MessageOrInteraction
 
-export interface CommandExecuteOptions {
+export type CommandExecuteOptions<Args extends CommandArg[]> = {
   slash: boolean
-  params: any
+  args: {
+    [K in Args[number]['name']]: any
+  }
 }
 
-export interface ArgumentResolver {
-  get: <T>(name: string) => T
-}
-
-export type CommandExecute<Slash extends boolean> = (
+export type CommandExecute<Slash extends boolean, Args extends CommandArg[]> = (
   client: Client,
   entity: ExecuteArgument<Slash>,
-  options: CommandExecuteOptions
+  options: CommandExecuteOptions<Args>
 ) => void
 
-export interface CommandContext {
-  name: string
-  category: string
-  slash: boolean
-  execute: CommandExecute<boolean>
-}
-
 export interface CommandOptions {
   name?: string
   description?: string
@@ -82,9 +71,14 @@ export interface CommandOptions {
   cooldown?: number
 }
 
-export type HarmonixCommandInput = string | HarmonixCommand<boolean>
+export type HarmonixCommandInput =
+  | string
+  | HarmonixCommand<boolean, CommandArg[]>
 
-export interface HarmonixCommand<Slash extends boolean> {
+export interface HarmonixCommand<
+  Slash extends boolean,
+  Args extends CommandArg[]
+> {
   options: CommandOptions
-  execute: CommandExecute<Slash>
+  execute: CommandExecute<Slash, Args>
 }