feat: add guildOnly command and all commands are slash

Author: davidabou

src/define.ts

@@ -9,11 +9,10 @@ import {
 } from 'discord.js'
 import type { Stream } from 'node:stream'
 import type {
-  ArgsDef,
+  CommandConfig,
   CommandExecute,
-  CommandOptions,
   ContextMenuCallback,
-  ContextMenuOptions,
+  ContextMenuConfig,
   DefineContextMenu,
   DefineContextMenuWithOptions,
   DefineEvent,
@@ -29,6 +28,7 @@ import type {
   HarmonixEvent,
   HarmonixEvents,
   ModalOptions,
+  OptionsDef,
   PreconditionCallback
 } from './types'
 
@@ -64,41 +64,38 @@ export const defineEvent: DefineEvent & DefineEventWithOptions = <
   }
 }
 
-export const defineCommand = <
-  K extends boolean = boolean,
-  T extends ArgsDef = ArgsDef
->(
-  options: CommandOptions<K> & { slash?: K; args?: T },
-  execute: CommandExecute<K, T>
-): HarmonixCommand<K, T> => {
-  return { options, execute }
+export const defineCommand = <T extends OptionsDef = OptionsDef>(
+  config: CommandConfig & { options?: T },
+  execute: CommandExecute<T>
+): HarmonixCommand<T> => {
+  return { config, execute }
 }
 
 export const defineContextMenu: DefineContextMenu &
   DefineContextMenuWithOptions = <Type extends 'message' | 'user'>(
   ...args: [
-    ContextMenuOptions | ContextMenuCallback<Type>,
+    ContextMenuConfig | ContextMenuCallback<Type>,
     ContextMenuCallback<Type>?
   ]
 ): HarmonixContextMenu => {
-  let options: ContextMenuOptions = {}
+  let config: ContextMenuConfig = {}
 
   if (args.length === 1) {
     const [callback] = args as [ContextMenuCallback<Type>]
 
     return {
-      options,
+      config,
       callback
     }
   } else {
-    const [opts, callback] = args as [
-      ContextMenuOptions,
+    const [cfg, callback] = args as [
+      ContextMenuConfig,
       ContextMenuCallback<Type>
     ]
 
-    options = opts
+    config = cfg
     return {
-      options,
+      config,
       callback
     }
   }

src/discord.ts

@@ -6,7 +6,7 @@ import { createError, ctx } from './harmonix'
 import { contextMenuToJSON, isHarmonixCommand, slashToJSON } from './utils'
 
 export const initCient = (harmonixOptions: Harmonix['options']) => {
-  const client = new Client(harmonixOptions.clientOptions)
+  const client = new Client(harmonixOptions.client)
 
   client.login(process.env.DISCORD_CLIENT_TOKEN)
 
@@ -15,7 +15,7 @@ export const initCient = (harmonixOptions: Harmonix['options']) => {
 
 export const refreshApplicationCommands = async (harmonix: Harmonix) => {
   const commands = [
-    ...harmonix.commands.filter((cmd) => cmd.options.slash).map((cmd) => cmd),
+    ...harmonix.commands.map((cmd) => cmd),
     ...harmonix.contextMenus.map((cmd) => cmd)
   ]
   const rest = new REST().setToken(process.env.DISCORD_CLIENT_TOKEN!)
@@ -26,18 +26,40 @@ export const refreshApplicationCommands = async (harmonix: Harmonix) => {
       await rest.put(
         Routes.applicationCommands(harmonix.options.clientId || client.user.id),
         {
-          body: commands.map((cmd) =>
-            isHarmonixCommand(cmd) ? slashToJSON(cmd) : contextMenuToJSON(cmd)
-          )
+          body: commands
+            .filter((cmd) => !cmd.config.guildOnly)
+            .map((cmd) =>
+              isHarmonixCommand(cmd) ? slashToJSON(cmd) : contextMenuToJSON(cmd)
+            )
         }
       )
+      if (harmonix.options.guildId) {
+        for (const guildId of harmonix.options.guildId) {
+          await rest.put(
+            Routes.applicationGuildCommands(
+              harmonix.options.clientId || client.user.id,
+              guildId
+            ),
+            {
+              body: commands
+                .filter((cmd) => cmd.config.guildOnly)
+                .map((cmd) =>
+                  isHarmonixCommand(cmd)
+                    ? slashToJSON(cmd)
+                    : contextMenuToJSON(cmd)
+                )
+            }
+          )
+        }
+      }
       consola.success('Successfully reloaded application commands.\n')
       const readyEvent = harmonix.events.get('ready')
 
       if (readyEvent) {
         ctx.call(harmonix, () => readyEvent.callback(client))
       }
     } catch (error: any) {
+      console.log(error)
       createError(error.message)
     }
   })

src/harmonix.ts

@@ -18,13 +18,12 @@ import {
 } from './load'
 import { initCient, refreshApplicationCommands } from './discord'
 import {
-  registerMessageCommands,
   registerContextMenu,
   registerEvents,
-  registerSlashCommands
+  registerCommands
 } from './register'
 import {
-  resolveMessageCommand,
+  resolveCommand,
   resolveContextMenu,
   resolveEvent,
   resolvePrecondition
@@ -51,9 +50,7 @@ export const createHarmonix = async (
 
   const scannedCommands = await scanCommands(harmonix)
   const _commands = [...(harmonix.options.commands || []), ...scannedCommands]
-  const commands = _commands.map((cmd) =>
-    resolveMessageCommand(cmd, harmonix.options)
-  )
+  const commands = _commands.map((cmd) => resolveCommand(cmd, harmonix.options))
 
   const scannedEvents = await scanEvents(harmonix)
   const _events = [...(harmonix.options.events || []), ...scannedEvents]
@@ -93,8 +90,7 @@ export const createHarmonix = async (
 
   registerEvents(harmonix)
   await refreshApplicationCommands(harmonix)
-  registerMessageCommands(harmonix)
-  registerSlashCommands(harmonix)
+  registerCommands(harmonix)
   registerContextMenu(harmonix)
 
   return harmonix

src/load.ts

@@ -17,7 +17,7 @@ export const loadCommands = (
   commands: HarmonixCommand[]
 ) => {
   for (const cmd of commands) {
-    harmonix.commands.set(cmd.options.name!, cmd)
+    harmonix.commands.set(cmd.config.name!, cmd)
   }
 }
 
@@ -26,7 +26,7 @@ export const loadContextMenus = (
   contextMenus: HarmonixContextMenu[]
 ) => {
   for (const ctm of contextMenus) {
-    harmonix.contextMenus.set(ctm.options.name!, ctm)
+    harmonix.contextMenus.set(ctm.config.name!, ctm)
   }
 }
 

src/options.ts

@@ -41,15 +41,15 @@ export const loadOptions = async (
   options.scanDirs = [...new Set(options.scanDirs)]
   options.defaultPrefix = options.defaultPrefix || '!'
 
-  const intents = options.clientOptions?.intents || [
+  const intents = options.client?.intents || [
     'Guilds',
     'GuildMessages',
     'MessageContent',
     'GuildMembers'
   ]
 
-  options.clientOptions = options.clientOptions || {}
-  options.clientOptions.intents = intents
+  options.client = options.client || {}
+  options.client.intents = intents
 
   return options
 }

src/register.ts

@@ -1,9 +1,9 @@
 import { Events } from 'discord.js'
 import consola from 'consola'
 import { colors } from 'consola/utils'
-import { optionToArg, resolveArgument } from './utils'
+import { toOption, resolveOption } from './utils'
 import { ctx } from './harmonix'
-import type { Harmonix, HarmonixEvents, ParsedArgs } from './types'
+import type { Harmonix, HarmonixEvents, ParsedOptions } from './types'
 
 export const registerEvents = (harmonix: Harmonix) => {
   for (const [, event] of harmonix.events.filter((evt) => !evt.options.type)) {
@@ -36,86 +36,32 @@ export const registerEvents = (harmonix: Harmonix) => {
   })
 }
 
-export const registerMessageCommands = (harmonix: Harmonix) => {
-  harmonix.client?.on(Events.MessageCreate, async (message) => {
-    if (message.author.bot) return
-    const prefix = harmonix.options.defaultPrefix
-    const rawArgs = message.content.slice(prefix.length).trim().split(/ +/)
-    const command = rawArgs.shift()?.toLowerCase()
-
-    if (!command) return
-    const cmd = harmonix.commands
-      .filter((cmd) => !cmd.options.slash)
-      .find((cmd) => cmd.options.name === command)
+export const registerCommands = (harmonix: Harmonix) => {
+  harmonix.client?.on(Events.InteractionCreate, async (interaction) => {
+    if (!interaction.isChatInputCommand()) return
+    const cmd = harmonix.commands.find(
+      (cmd) => cmd.config.name === interaction.commandName
+    )
 
     if (!cmd) return
-    const args = await Object.keys(cmd.options.args || {}).reduce<
-      Promise<ParsedArgs>
-    >(async (acc, arg, index) => {
+    const options = await interaction.options.data.reduce<
+      Promise<ParsedOptions>
+    >(async (acc, opt) => {
       const resolvedAcc = await acc
-      const resolvedArg = await resolveArgument(
-        message,
-        cmd.options.args![arg].type,
-        rawArgs[index]
+      const resolvedOption = await resolveOption(
+        interaction,
+        toOption(opt.type),
+        String(opt.value)
       )
 
       return {
         ...resolvedAcc,
-        [arg]: resolvedArg
+        [opt.name]: resolvedOption
       }
     }, Promise.resolve({}))
 
-    if (cmd.options.preconditions) {
-      for (const prc of cmd.options.preconditions) {
-        const precondition = harmonix.preconditions.get(prc)
-
-        if (!precondition) {
-          consola.warn(`Precondition ${colors.cyan(prc)} not found.`)
-          continue
-        }
-        const result = ctx.call(harmonix, () => {
-          return precondition.callback({
-            type: 'message',
-            message
-          })
-        })
-
-        if (!result) return
-      }
-    }
-    ctx.call(harmonix, () => {
-      cmd.execute(harmonix.client!, message, { slash: false, args })
-    })
-  })
-}
-
-export const registerSlashCommands = (harmonix: Harmonix) => {
-  harmonix.client?.on(Events.InteractionCreate, async (interaction) => {
-    if (!interaction.isChatInputCommand()) return
-    const cmd = harmonix.commands
-      .filter((cmd) => cmd.options.slash)
-      .find((cmd) => cmd.options.name === interaction.commandName)
-
-    if (!cmd) return
-    const args = await interaction.options.data.reduce<Promise<ParsedArgs>>(
-      async (acc, opt) => {
-        const resolvedAcc = await acc
-        const resolvedArg = await resolveArgument(
-          interaction,
-          optionToArg(opt.type),
-          String(opt.value)
-        )
-
-        return {
-          ...resolvedAcc,
-          [opt.name]: resolvedArg
-        }
-      },
-      Promise.resolve({})
-    )
-
-    if (cmd.options.preconditions) {
-      for (const prc of cmd.options.preconditions) {
+    if (cmd.config.preconditions) {
+      for (const prc of cmd.config.preconditions) {
         const precondition = harmonix.preconditions.get(prc)
 
         if (!precondition) {
@@ -134,8 +80,7 @@ export const registerSlashCommands = (harmonix: Harmonix) => {
     }
     ctx.call(harmonix, () => {
       cmd.execute(harmonix.client!, interaction, {
-        slash: false,
-        args
+        options
       })
     })
   })
@@ -145,12 +90,12 @@ export const registerContextMenu = (harmonix: Harmonix) => {
   harmonix.client?.on(Events.InteractionCreate, async (interaction) => {
     if (!interaction.isContextMenuCommand()) return
     const ctm = harmonix.contextMenus.find(
-      (ctm) => ctm.options.name === interaction.commandName
+      (ctm) => ctm.config.name === interaction.commandName
     )
 
     if (!ctm) return
-    if (ctm.options.preconditions) {
-      for (const prc of ctm.options.preconditions) {
+    if (ctm.config.preconditions) {
+      for (const prc of ctm.config.preconditions) {
         const precondition = harmonix.preconditions.get(prc)
 
         if (!precondition) {