nv-kit 1.0.0

package/package.json

@@ -0,0 +1,16 @@
+{
+  "name": "nv-kit",
+  "version": "1.0.0",
+  "description": "",
+  "main": "src/index.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "dependencies": {
+    "discord.js": "^14.0.2",
+    "mongoose": "^6.3.5"
+  }
+}

package/src/command-handler/ChannelCommands.js

@@ -0,0 +1,52 @@
+const channelCommands = require('../models/channel-commands-schema')
+
+class ChannelCommands {
+  // `${guildId}-${commandName}`: [channelIds]
+  _channelCommands = new Map()
+
+  async action(action, guildId, commandName, channelId) {
+    const _id = `${guildId}-${commandName}`
+
+    const result = await channelCommands.findOneAndUpdate(
+      {
+        _id,
+      },
+      {
+        _id,
+        [action === 'add' ? '$addToSet' : '$pull']: {
+          channels: channelId,
+        },
+      },
+      {
+        upsert: true,
+        new: true,
+      }
+    )
+
+    this._channelCommands.set(_id, result.channels)
+    return result.channels
+  }
+
+  async add(guildId, commandName, channelId) {
+    return await this.action('add', guildId, commandName, channelId)
+  }
+
+  async remove(guildId, commandName, channelId) {
+    return await this.action('remove', guildId, commandName, channelId)
+  }
+
+  async getAvailableChannels(guildId, commandName) {
+    const _id = `${guildId}-${commandName}`
+    let channels = this._channelCommands.get(_id)
+
+    if (!channels) {
+      const results = await channelCommands.findById(_id)
+      channels = results ? results.channels : []
+      this._channelCommands.set(_id, channels)
+    }
+
+    return channels
+  }
+}
+
+module.exports = ChannelCommands

package/src/command-handler/Command.js

@@ -0,0 +1,21 @@
+class Command {
+  constructor(instance, commandName, commandObject) {
+    this._instance = instance
+    this._commandName = commandName.toLowerCase()
+    this._commandObject = commandObject
+  }
+
+  get instance() {
+    return this._instance
+  }
+
+  get commandName() {
+    return this._commandName
+  }
+
+  get commandObject() {
+    return this._commandObject
+  }
+}
+
+module.exports = Command

package/src/command-handler/CommandHandler.js

@@ -0,0 +1,219 @@
+const path = require('path')
+
+const getAllFiles = require('../util/get-all-files')
+const Command = require('./Command')
+const SlashCommands = require('./SlashCommands')
+const { cooldownTypes } = require('../util/Cooldowns')
+const ChannelCommands = require('./ChannelCommands')
+const CustomCommands = require('./CustomCommands')
+const DisabledCommands = require('./DisabledCommands')
+const PrefixHandler = require('./PrefixHandler')
+
+class CommandHandler {
+  // <commandName, instance of the Command class>
+  _commands = new Map()
+  _validations = this.getValidations(
+    path.join(__dirname, 'validations', 'runtime')
+  )
+  _channelCommands = new ChannelCommands()
+  _customCommands = new CustomCommands(this)
+  _disabledCommands = new DisabledCommands()
+  _prefixes = new PrefixHandler()
+
+  constructor(instance, commandsDir, client) {
+    this._instance = instance
+    this._commandsDir = commandsDir
+    this._slashCommands = new SlashCommands(client)
+    this._client = client
+
+    this._validations = [
+      ...this._validations,
+      ...this.getValidations(instance.validations?.runtime),
+    ]
+
+    this.readFiles()
+  }
+
+  get commands() {
+    return this._commands
+  }
+
+  get channelCommands() {
+    return this._channelCommands
+  }
+
+  get slashCommands() {
+    return this._slashCommands
+  }
+
+  get customCommands() {
+    return this._customCommands
+  }
+
+  get disabledCommands() {
+    return this._disabledCommands
+  }
+
+  get prefixHandler() {
+    return this._prefixes
+  }
+
+  async readFiles() {
+    const defaultCommands = getAllFiles(path.join(__dirname, './commands'))
+    const files = getAllFiles(this._commandsDir)
+    const validations = [
+      ...this.getValidations(path.join(__dirname, 'validations', 'syntax')),
+      ...this.getValidations(this._instance.validations?.syntax),
+    ]
+
+    for (let file of [...defaultCommands, ...files]) {
+      const commandObject = require(file)
+
+      let commandName = file.split(/[\/\\]/)
+      commandName = commandName.pop()
+      commandName = commandName.split('.')[0]
+
+      const command = new Command(this._instance, commandName, commandObject)
+
+      const {
+        description,
+        type,
+        testOnly,
+        delete: del,
+        aliases = [],
+        init = () => {},
+      } = commandObject
+
+      if (
+        del ||
+        this._instance.disabledDefaultCommands.includes(
+          commandName.toLowerCase()
+        )
+      ) {
+        if (type === 'SLASH' || type === 'BOTH') {
+          if (testOnly) {
+            for (const guildId of this._instance.testServers) {
+              this._slashCommands.delete(command.commandName, guildId)
+            }
+          } else {
+            this._slashCommands.delete(command.commandName)
+          }
+        }
+
+        return
+      }
+
+      for (const validation of validations) {
+        validation(command)
+      }
+
+      await init(this._client, this._instance)
+
+      const names = [command.commandName, ...aliases]
+
+      for (const name of names) {
+        this._commands.set(name, command)
+      }
+
+      if (type === 'SLASH' || type === 'BOTH') {
+        const options =
+          commandObject.options ||
+          this._slashCommands.createOptions(commandObject)
+
+        if (testOnly) {
+          for (const guildId of this._instance.testServers) {
+            this._slashCommands.create(
+              command.commandName,
+              description,
+              options,
+              guildId
+            )
+          }
+        } else {
+          this._slashCommands.create(command.commandName, description, options)
+        }
+      }
+    }
+  }
+
+  async runCommand(command, args, message, interaction) {
+    const { callback, type, cooldowns } = command.commandObject
+
+    if (message && type === 'SLASH') {
+      return
+    }
+
+    const guild = message ? message.guild : interaction.guild
+    const member = message ? message.member : interaction.member
+    const user = message ? message.author : interaction.user
+    const channel = message ? message.channel : interaction.channel
+
+    const usage = {
+      instance: command.instance,
+      message,
+      interaction,
+      args,
+      text: args.join(' '),
+      guild,
+      member,
+      user,
+      channel,
+    }
+
+    for (const validation of this._validations) {
+      if (!(await validation(command, usage, this._prefixes.get(guild?.id)))) {
+        return
+      }
+    }
+
+    if (cooldowns) {
+      let cooldownType
+
+      for (const type of cooldownTypes) {
+        if (cooldowns[type]) {
+          cooldownType = type
+          break
+        }
+      }
+
+      const cooldownUsage = {
+        cooldownType,
+        userId: user.id,
+        actionId: `command_${command.commandName}`,
+        guildId: guild?.id,
+        duration: cooldowns[cooldownType],
+        errorMessage: cooldowns.errorMessage,
+      }
+
+      const result = this._instance.cooldowns.canRunAction(cooldownUsage)
+
+      if (typeof result === 'string') {
+        return result
+      }
+
+      await this._instance.cooldowns.start(cooldownUsage)
+
+      usage.cancelCooldown = () => {
+        this._instance.cooldowns.cancelCooldown(cooldownUsage)
+      }
+
+      usage.updateCooldown = (expires) => {
+        this._instance.cooldowns.updateCooldown(cooldownUsage, expires)
+      }
+    }
+
+    return await callback(usage)
+  }
+
+  getValidations(folder) {
+    if (!folder) {
+      return []
+    }
+
+    const validations = getAllFiles(folder).map((filePath) => require(filePath))
+
+    return validations
+  }
+}
+
+module.exports = CommandHandler

package/src/command-handler/CustomCommands.js

@@ -0,0 +1,74 @@
+const customCommandSchema = require('../models/custom-command-schema')
+
+class CustomCommands {
+  // guildId-commandName: response
+  _customCommands = new Map()
+
+  constructor(commandHandler) {
+    this._commandHandler = commandHandler
+    this.loadCommands()
+  }
+
+  async loadCommands() {
+    const results = await customCommandSchema.find({})
+
+    for (const result of results) {
+      const { _id, response } = result
+      this._customCommands.set(_id, response)
+    }
+  }
+
+  async create(guildId, commandName, description, response) {
+    const _id = `${guildId}-${commandName}`
+
+    this._customCommands.set(_id, response)
+
+    this._commandHandler.slashCommands.create(
+      commandName,
+      description,
+      [],
+      guildId
+    )
+
+    await customCommandSchema.findOneAndUpdate(
+      {
+        _id,
+      },
+      {
+        _id,
+        response,
+      },
+      {
+        upsert: true,
+      }
+    )
+  }
+
+  async delete(guildId, commandName) {
+    const _id = `${guildId}-${commandName}`
+
+    this._customCommands.delete(_id)
+
+    this._commandHandler.slashCommands.delete(commandName, guildId)
+
+    await customCommandSchema.deleteOne({ _id })
+  }
+
+  async run(commandName, message, interaction) {
+    const guild = message ? message.guild : interaction.guild
+    if (!guild) {
+      return
+    }
+
+    const _id = `${guild.id}-${commandName}`
+    const response = this._customCommands.get(_id)
+    if (!response) {
+      return
+    }
+
+    if (message) message.channel.send(response).catch(() => {})
+    else if (interaction) interaction.reply(response).catch(() => {})
+  }
+}
+
+module.exports = CustomCommands

package/src/command-handler/DisabledCommands.js

@@ -0,0 +1,50 @@
+const disabledCommandSchema = require('../models/disabled-commands-schema')
+
+class DisabledCommands {
+  // array of `${guildId}-${commandName}`
+  _disabledCommands = []
+
+  constructor() {
+    this.loadDisabledCommands()
+  }
+
+  async loadDisabledCommands() {
+    const results = await disabledCommandSchema.find({})
+
+    for (const result of results) {
+      this._disabledCommands.push(result._id)
+    }
+  }
+
+  async disable(guildId, commandName) {
+    if (this.isDisabled(guildId, commandName)) {
+      return
+    }
+
+    const _id = `${guildId}-${commandName}`
+    this._disabledCommands.push(_id)
+
+    try {
+      await new disabledCommandSchema({
+        _id,
+      }).save()
+    } catch (ignored) {}
+  }
+
+  async enable(guildId, commandName) {
+    if (!this.isDisabled(guildId, commandName)) {
+      return
+    }
+
+    const _id = `${guildId}-${commandName}`
+    this._disabledCommands = this._disabledCommands.filter((id) => id !== _id)
+
+    await disabledCommandSchema.deleteOne({ _id })
+  }
+
+  isDisabled(guildId, commandName) {
+    return this._disabledCommands.includes(`${guildId}-${commandName}`)
+  }
+}
+
+module.exports = DisabledCommands

package/src/command-handler/PrefixHandler.js

@@ -0,0 +1,50 @@
+const guildPrefixSchema = require('../models/guild-prefix-schema')
+
+class PrefixHandler {
+  // <guildId: prefix>
+  _prefixes = new Map()
+  _defaultPrefix = '!'
+
+  constructor() {
+    this.loadPrefixes()
+  }
+
+  async loadPrefixes() {
+    const results = await guildPrefixSchema.find({})
+
+    for (const result of results) {
+      this._prefixes.set(result._id, result.prefix)
+    }
+  }
+
+  get defaultPrefix() {
+    return this._defaultPrefix
+  }
+
+  get(guildId) {
+    if (!guildId) {
+      return defaultPrefix
+    }
+
+    return this._prefixes.get(guildId) || this.defaultPrefix
+  }
+
+  async set(guildId, prefix) {
+    this._prefixes.set(guildId, prefix)
+
+    await guildPrefixSchema.findOneAndUpdate(
+      {
+        _id: guildId,
+      },
+      {
+        _id: guildId,
+        prefix,
+      },
+      {
+        upsert: true,
+      }
+    )
+  }
+}
+
+module.exports = PrefixHandler

package/src/command-handler/SlashCommands.js

@@ -0,0 +1,111 @@
+const { ApplicationCommandOptionType } = require('discord.js')
+
+class SlashCommands {
+  constructor(client) {
+    this._client = client
+  }
+
+  async getCommands(guildId) {
+    let commands
+
+    if (guildId) {
+      const guild = await this._client.guilds.fetch(guildId)
+      commands = guild.commands
+    } else {
+      commands = this._client.application.commands
+    }
+
+    await commands.fetch()
+
+    return commands
+  }
+
+  areOptionsDifferent(options, existingOptions) {
+    for (let a = 0; a < options.length; ++a) {
+      const option = options[a]
+      const existing = existingOptions[a]
+
+      if (
+        option.name !== existing.name ||
+        option.type !== existing.type ||
+        option.description !== existing.description
+      ) {
+        return true
+      }
+    }
+
+    return false
+  }
+
+  async create(name, description, options, guildId) {
+    const commands = await this.getCommands(guildId)
+
+    const existingCommand = commands.cache.find((cmd) => cmd.name === name)
+    if (existingCommand) {
+      const { description: existingDescription, options: existingOptions } =
+        existingCommand
+
+      if (
+        description !== existingDescription ||
+        options.length !== existingOptions.length ||
+        this.areOptionsDifferent(options, existingOptions)
+      ) {
+        console.log(`Updating the command "${name}"`)
+
+        await commands.edit(existingCommand.id, {
+          description,
+          options,
+        })
+      }
+      return
+    }
+
+    await commands.create({
+      name,
+      description,
+      options,
+    })
+  }
+
+  async delete(commandName, guildId) {
+    const commands = await this.getCommands(guildId)
+
+    const existingCommand = commands.cache.find(
+      (cmd) => cmd.name === commandName
+    )
+    if (!existingCommand) {
+      return
+    }
+
+    await existingCommand.delete()
+  }
+
+  createOptions({ expectedArgs = '', minArgs = 0 }) {
+    const options = []
+
+    // <num 1> <num 2>
+
+    if (expectedArgs) {
+      const split = expectedArgs
+        .substring(1, expectedArgs.length - 1)
+        // num 1> <num 2
+        .split(/[>\]] [<\[]/)
+      // ['num 1', 'num 2']
+
+      for (let a = 0; a < split.length; ++a) {
+        const arg = split[a]
+
+        options.push({
+          name: arg.toLowerCase().replace(/\s+/g, '-'),
+          description: arg,
+          type: ApplicationCommandOptionType.String,
+          required: a < minArgs,
+        })
+      }
+    }
+
+    return options
+  }
+}
+
+module.exports = SlashCommands

package/src/command-handler/commands/channelcommand.js

@@ -0,0 +1,69 @@
+const { ApplicationCommandOptionType } = require('discord.js')
+
+module.exports = {
+  description: 'Specifies what commands can be ran inside of what channels',
+
+  type: 'SLASH',
+  testOnly: true,
+  guildOnly: true,
+
+  options: [
+    {
+      name: 'command',
+      description: 'The command to restrict to specific channels',
+      required: true,
+      type: ApplicationCommandOptionType.String,
+      autocomplete: true,
+    },
+    {
+      name: 'channel',
+      description: 'The channel to use for this command',
+      required: true,
+      type: ApplicationCommandOptionType.Channel,
+    },
+  ],
+
+  autocomplete: (_, command) => {
+    return [...command.instance.commandHandler.commands.keys()]
+  },
+
+  callback: async ({ instance, guild, interaction }) => {
+    const commandName = interaction.options.getString('command')
+    const channel = interaction.options.getChannel('channel')
+
+    const command = instance.commandHandler.commands.get(
+      commandName.toLowerCase()
+    )
+    if (!command) {
+      return `The command "${commandName}" does not exist.`
+    }
+
+    const { channelCommands } = instance.commandHandler
+
+    let availableChannels = []
+    const canRun = (
+      await channelCommands.getAvailableChannels(guild.id, commandName)
+    ).includes(channel.id)
+
+    if (canRun) {
+      availableChannels = await channelCommands.remove(
+        guild.id,
+        commandName,
+        channel.id
+      )
+    } else {
+      availableChannels = await channelCommands.add(
+        guild.id,
+        commandName,
+        channel.id
+      )
+    }
+
+    if (availableChannels.length) {
+      const channelNames = availableChannels.map((c) => `<#${c}> `)
+      return `The command "${commandName}" can now only be ran inside of the following channels: ${channelNames}`
+    }
+
+    return `The command "${commandName}" can now be ran inside of any text channel.`
+  },
+}

package/src/command-handler/commands/customcommand.js

@@ -0,0 +1,28 @@
+const { PermissionFlagsBits } = require('discord.js')
+
+module.exports = {
+  description: 'Creates a custom command',
+
+  minArgs: 3,
+  syntaxError: 'Correct syntax: {PREFIX}customCommand {ARGS}',
+  expectedArgs: '<command name> <description> <response>',
+
+  type: 'SLASH',
+  guildOnly: true,
+  testOnly: true,
+
+  permissions: [PermissionFlagsBits.Administrator],
+
+  callback: async ({ instance, args, guild }) => {
+    const [commandName, description, response] = args
+
+    await instance.commandHandler.customCommands.create(
+      guild.id,
+      commandName,
+      description,
+      response
+    )
+
+    return `Custom command "${commandName}" has been created!`
+  },
+}