refactor: use scan files and remove classes

Author: davidabou

bin/index.mjs

@@ -1,15 +1,14 @@
 #!/usr/bin/env node
 
-import { Harmony } from '../dist/index.mjs'
-import { resolve } from 'pathe'
+import { createHarmony } from '../dist/index.mjs'
 import 'dotenv/config'
 
 const initHarmony = async () => {
-  const harmony = await Harmony.create({ cwd: resolve('./playground') })
-
+  const harmony = await createHarmony(
+    { rootDir: './playground' },
+    { cwd: './playground' }
+  )
   console.log(harmony)
-
-  harmony.initClient()
 }
 
 initHarmony()

package.json

@@ -18,6 +18,7 @@
     "defu": "^6.1.4",
     "discord.js": "^14.15.1",
     "dotenv": "^16.4.5",
+    "globby": "^14.0.1",
     "jiti": "^1.21.0",
     "pathe": "^1.1.2",
     "unbuild": "^2.0.0"

playground/harmony.config.ts

@@ -1,3 +1,5 @@
 import { defineHarmonyConfig } from '../src'
 
-export default defineHarmonyConfig({})
+export default defineHarmonyConfig({
+  defaultPrefix: 'h!'
+})

pnpm-lock.yaml

@@ -1,84 +1,41 @@
-import createJiti from 'jiti'
-import { filename } from 'pathe/utils'
-import type { CommandExecute, CommandResult } from '../types'
+import jiti from 'jiti'
 import { dirname } from 'pathe'
-
-const jiti = createJiti(undefined as unknown as string, {
-  interopDefault: true,
-  requireCache: false,
-  esmResolve: true,
-  extensions: ['.ts', '.js']
-})
-
-interface CommandContext {
-  name: string
-  category: string
-  slash: boolean
-  execute: CommandExecute<boolean>
-}
-
-interface CommandOptions {
-  name?: string
-  description?: string
-  category?: string
-  arguments?: any[]
-  nsfw?: boolean
-  slash?: boolean
-  ownerOnly?: boolean
-  guildOnly?: boolean
-  userPermissions?: any[]
-  botPermissions?: any[]
-  cooldown?: number
-}
-
-export class Command {
-  public name: string
-  public description: string
-  public category: string
-  public arguments: any[]
-  public nsfw: boolean
-  public slash: boolean
-  public ownerOnly: boolean
-  public guildOnly: boolean
-  public userPermissions: any[]
-  public botPermissions: any[]
-  public cooldown: number
-
-  public execute: CommandExecute<boolean>
-
-  constructor(context: CommandContext, options: CommandOptions = {}) {
-    this.name = options.name ?? context.name
-    this.description = options.description ?? ''
-    this.category = options.category ?? context.category
-    this.arguments = options.arguments ?? []
-    this.nsfw = options.nsfw ?? false
-    this.slash = options.slash || context.slash
-    this.ownerOnly = options.ownerOnly ?? false
-    this.guildOnly = options.guildOnly ?? false
-    this.userPermissions = options.userPermissions ?? []
-    this.botPermissions = options.botPermissions ?? []
-    this.cooldown = options.cooldown ?? 0
-
-    this.execute = context.execute
-  }
-}
-
-export const getCommand = (path: string) => {
-  const command = jiti(path) as CommandResult<boolean>
-  const context: CommandContext = {
-    name: filename(path).split('.')[0],
-    category: filename(dirname(path)),
-    slash: filename(path).endsWith('.slash'),
-    execute: command.execute
+import { filename } from 'pathe/utils'
+import type {
+  CommandExecute,
+  CommandOptions,
+  HarmonyCommand,
+  HarmonyCommandInput
+} from '../types'
+import { Harmony } from './harmony'
+
+export const resolveHarmonyCommand = (
+  cmd: HarmonyCommandInput,
+  harmonyOptions: Harmony['options']
+): HarmonyCommand<boolean> => {
+  if (typeof cmd === 'string') {
+    const _jiti = jiti(harmonyOptions.rootDir, {
+      interopDefault: true
+    })
+    const _cmdPath = _jiti.resolve(cmd)
+    const command = _jiti(_cmdPath) as HarmonyCommand<boolean>
+    const options: CommandOptions = {
+      name: filename(_cmdPath).split('.')[0],
+      category: filename(dirname(_cmdPath)),
+      slash: command.options.slash || filename(_cmdPath).endsWith('.slash'),
+      ...command.options
+    }
+
+    return { options, execute: command.execute }
+  } else {
+    return cmd
   }
-
-  return new Command(context, command.options)
 }
 
 export const defineCommand = <Slash extends boolean>(
   options: CommandOptions & { slash?: Slash },
   execute: CommandExecute<Slash>
-): CommandResult<Slash> => {
+): HarmonyCommand<Slash> => {
   return {
     options,
     execute

src/commands.ts

@@ -1,27 +1,42 @@
 import { LoadConfigOptions, loadConfig } from 'c12'
-import { defu } from 'defu'
+import { resolve } from 'pathe'
 import type { HarmonyConfig } from '../types'
 
-export interface LoadHarmonyConfigOptions
-  extends LoadConfigOptions<HarmonyConfig> {}
+const HarmonyDefaults: HarmonyConfig = {
+  scanDirs: [],
+  ignore: []
+}
 
-export const loadHarmonyConfig = async (opts: LoadHarmonyConfigOptions) => {
+export const loadOptions = async (
+  configOverrides: HarmonyConfig = {},
+  opts: LoadConfigOptions
+) => {
   const { config } = await loadConfig<HarmonyConfig>({
     name: 'harmony',
     configFile: 'harmony.config',
     rcFile: '.harmonyrc',
     dotenv: true,
     globalRc: true,
+    overrides: configOverrides,
+    defaults: HarmonyDefaults,
     ...opts
   })
 
-  return defu(config, {
-    defaultPrefix: '!',
-    dir: {
-      commands: './commands',
-      events: './events'
-    }
-  })
+  if (!config) {
+    throw new Error('No configuration found')
+  }
+  const options = config
+
+  options.rootDir = resolve(options.rootDir || '.')
+  options.srcDir = resolve(options.srcDir || options.rootDir)
+  options.scanDirs?.unshift(options.srcDir)
+  options.scanDirs = options.scanDirs?.map((dir) =>
+    resolve(options.srcDir!, dir!)
+  )
+  options.scanDirs = [...new Set(options.scanDirs)]
+  options.defaultPrefix = options.defaultPrefix || '!'
+
+  return options
 }
 
 export const defineHarmonyConfig = (config: HarmonyConfig) => {

src/config.ts

@@ -1,57 +1,39 @@
-import createJiti from 'jiti'
+import jiti from 'jiti'
 import { filename } from 'pathe/utils'
 import type {
   DefineEvent,
   DefineEventWithOptions,
   EventCallback,
-  EventResult
+  EventOptions,
+  HarmonyEvent,
+  HarmonyEventInput
 } from '../types'
+import { Harmony } from './harmony'
+
+export const resolveHarmonyEvent = (
+  evt: HarmonyEventInput,
+  harmonyOptions: Harmony['options']
+): HarmonyEvent => {
+  if (typeof evt === 'string') {
+    const _jiti = jiti(harmonyOptions.rootDir, {
+      interopDefault: true
+    })
+    const _evtPath = _jiti.resolve(evt)
+    const event = _jiti(_evtPath) as HarmonyEvent
+    const options: EventOptions = {
+      name: filename(_evtPath).split('.')[0],
+      once: event.options.once || filename(_evtPath).endsWith('.once')
+    }
 
-const jiti = createJiti(undefined as unknown as string, {
-  interopDefault: true,
-  requireCache: false,
-  esmResolve: true,
-  extensions: ['.ts', '.js']
-})
-
-interface EventContext {
-  name: string
-  once: boolean
-  execute: EventCallback
-}
-
-interface EventOptions {
-  once?: boolean
-}
-
-export class Event {
-  public name: string
-  public once: boolean
-
-  public callback: EventCallback
-
-  constructor(context: EventContext, options: EventOptions = {}) {
-    this.name = context.name
-    this.once = options.once || context.once
-
-    this.callback = context.execute
-  }
-}
-
-export const getEvent = (path: string) => {
-  const event = jiti(path) as EventResult
-  const context: EventContext = {
-    name: filename(path).split('.')[0],
-    once: filename(path).endsWith('.once'),
-    execute: event.callback
+    return { options, callback: event.callback }
+  } else {
+    return evt
   }
-
-  return new Event(context, event.options)
 }
 
 export const defineEvent: DefineEvent & DefineEventWithOptions = (
   ...args: [EventOptions | EventCallback, EventCallback?]
-): EventResult => {
+): HarmonyEvent => {
   let options: EventOptions = {}
 
   if (args.length === 1) {