nv-kit 1.0.0

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

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

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

@@ -0,0 +1,21 @@
+const { PermissionFlagsBits } = require('discord.js')
+
+module.exports = {
+  description: 'Sets the prefix for this server',
+
+  minArgs: 1,
+  syntaxError: 'Correct syntax: {PREFIX}prefix {ARGS}',
+  expectedArgs: '<prefix>',
+
+  type: 'BOTH',
+  testOnly: true,
+  guildOnly: true,
+
+  permissions: [PermissionFlagsBits.Administrator],
+
+  callback: ({ instance, guild, text: prefix }) => {
+    instance.commandHandler.prefixHandler.set(guild.id, prefix)
+
+    return `Set "${prefix}" as the command prefix for this server.`
+  },
+}

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

@@ -0,0 +1,110 @@
+const {
+  PermissionFlagsBits,
+  ApplicationCommandOptionType,
+} = require('discord.js')
+const requiredPermissions = require('../../models/required-permissions-schema')
+
+const clearAllPermissions = 'Clear All Permissions'
+
+module.exports = {
+  description: 'Sets what commands require what permissions',
+
+  type: 'SLASH',
+  testOnly: true,
+  guildOnly: true,
+
+  permissions: [PermissionFlagsBits.Administrator],
+
+  options: [
+    {
+      name: 'command',
+      description: 'The command to set permissions to',
+      type: ApplicationCommandOptionType.String,
+      required: true,
+      autocomplete: true,
+    },
+    {
+      name: 'permission',
+      description: 'The permission to set for the command',
+      type: ApplicationCommandOptionType.String,
+      required: false,
+      autocomplete: true,
+    },
+  ],
+
+  autocomplete: (_, command, arg) => {
+    if (arg === 'command') {
+      return [...command.instance.commandHandler.commands.keys()]
+    } else if (arg === 'permission') {
+      return [clearAllPermissions, ...Object.keys(PermissionFlagsBits)]
+    }
+  },
+
+  callback: async ({ instance, guild, args }) => {
+    const [commandName, permission] = args
+
+    const command = instance.commandHandler.commands.get(commandName)
+    if (!command) {
+      return `The command "${commandName}" does not exist.`
+    }
+
+    const _id = `${guild.id}-${command.commandName}`
+
+    if (!permission) {
+      const document = await requiredPermissions.findById(_id)
+
+      const permissions =
+        document && document.permissions?.length
+          ? document.permissions.join(', ')
+          : 'None.'
+
+      return `Here are the permissions for "${commandName}": ${permissions}`
+    }
+
+    if (permission === clearAllPermissions) {
+      await requiredPermissions.deleteOne({ _id })
+
+      return `The command "${commandName}" no longer requires any permissions.`
+    }
+
+    const alreadyExists = await requiredPermissions.findOne({
+      _id,
+      permissions: {
+        $in: [permission],
+      },
+    })
+
+    if (alreadyExists) {
+      await requiredPermissions.findOneAndUpdate(
+        {
+          _id,
+        },
+        {
+          _id,
+          $pull: {
+            permissions: permission,
+          },
+        }
+      )
+
+      return `The command "${commandName}" no longer requires the permission "${permission}"`
+    }
+
+    await requiredPermissions.findOneAndUpdate(
+      {
+        _id,
+      },
+      {
+        _id,
+        $addToSet: {
+          permissions: permission,
+        },
+      },
+      {
+        upsert: true,
+      }
+    )
+
+    return `The command "${commandName}" now requires the permission "${permission}"`
+  },
+}

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

@@ -0,0 +1,112 @@
+const {
+  PermissionFlagsBits,
+  ApplicationCommandOptionType,
+} = require('discord.js')
+const requiredroles = require('../../models/required-roles-schema')
+
+module.exports = {
+  description: 'Sets what commands require what roles',
+
+  type: 'SLASH',
+  testOnly: true,
+  guildOnly: true,
+
+  roles: [PermissionFlagsBits.Administrator],
+
+  options: [
+    {
+      name: 'command',
+      description: 'The command to set roles to',
+      type: ApplicationCommandOptionType.String,
+      required: true,
+      autocomplete: true,
+    },
+    {
+      name: 'role',
+      description: 'The role to set for the command',
+      type: ApplicationCommandOptionType.Role,
+      required: false,
+    },
+  ],
+
+  autocomplete: (_, command) => {
+    return [...command.instance.commandHandler.commands.keys()]
+  },
+
+  callback: async ({ instance, guild, args }) => {
+    const [commandName, role] = args
+
+    const command = instance.commandHandler.commands.get(commandName)
+    if (!command) {
+      return `The command "${commandName}" does not exist.`
+    }
+
+    const _id = `${guild.id}-${command.commandName}`
+
+    if (!role) {
+      const document = await requiredroles.findById(_id)
+
+      const roles =
+        document && document.roles?.length
+          ? document.roles.map((roleId) => `<@&${roleId}>`)
+          : 'None.'
+
+      return {
+        content: `Here are the roles for "${commandName}": ${roles}`,
+        allowedMentions: {
+          roles: [],
+        },
+      }
+    }
+
+    const alreadyExists = await requiredroles.findOne({
+      _id,
+      roles: {
+        $in: [role],
+      },
+    })
+
+    if (alreadyExists) {
+      await requiredroles.findOneAndUpdate(
+        {
+          _id,
+        },
+        {
+          _id,
+          $pull: {
+            roles: role,
+          },
+        }
+      )
+
+      return {
+        content: `The command "${commandName}" no longer requires the role <@&${role}>`,
+        allowedMentions: {
+          roles: [],
+        },
+      }
+    }
+
+    await requiredroles.findOneAndUpdate(
+      {
+        _id,
+      },
+      {
+        _id,
+        $addToSet: {
+          roles: role,
+        },
+      },
+      {
+        upsert: true,
+      }
+    )
+
+    return {
+      content: `The command "${commandName}" now requires the role <@&${role}>`,
+      allowedMentions: {
+        roles: [],
+      },
+    }
+  },
+}

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

@@ -0,0 +1,42 @@
+const {
+  PermissionFlagsBits,
+  ApplicationCommandOptionType,
+} = require('discord.js')
+
+module.exports = {
+  description: 'Toggles a command on or off for your guild',
+
+  type: 'SLASH',
+  guildOnly: true,
+  testOnly: true,
+
+  permissions: [PermissionFlagsBits.Administrator],
+
+  options: [
+    {
+      name: 'command',
+      description: 'The command to toggle on or off',
+      type: ApplicationCommandOptionType.String,
+      required: true,
+      autocomplete: true,
+    },
+  ],
+
+  autocomplete: (_, command) => {
+    return [...command.instance.commandHandler.commands.keys()]
+  },
+
+  callback: async ({ instance, guild, text: commandName, interaction }) => {
+    const { disabledCommands } = instance.commandHandler
+
+    if (disabledCommands.isDisabled(guild.id, commandName)) {
+      await disabledCommands.enable(guild.id, commandName)
+
+      interaction.reply(`Command "${commandName}" has been enabled`)
+    } else {
+      await disabledCommands.disable(guild.id, commandName)
+
+      interaction.reply(`Command "${commandName}" has been disabled`)
+    }
+  },
+}

package/src/command-handler/validations/run-time/argument-count.js

@@ -0,0 +1,24 @@
+module.exports = (command, usage, prefix) => {
+  const {
+    minArgs = 0,
+    maxArgs = -1,
+    correctSyntax,
+    expectedArgs = '',
+  } = command.commandObject
+  const { length } = usage.args
+
+  if (length < minArgs || (length > maxArgs && maxArgs !== -1)) {
+    const text = correctSyntax
+      .replace('{PREFIX}', prefix)
+      .replace('{ARGS}', expectedArgs)
+
+    const { message, interaction } = usage
+
+    if (message) message.reply(text)
+    else if (interaction) interaction.reply(text)
+
+    return false
+  }
+
+  return true
+}

package/src/command-handler/validations/run-time/channel-command.js

@@ -0,0 +1,26 @@
+module.exports = async (command, usage) => {
+  const { commandName, instance } = command
+  const { guild, channel, message, interaction } = usage
+
+  if (!guild) {
+    return true
+  }
+
+  const availableChannels =
+    await instance.commandHandler.channelCommands.getAvailableChannels(
+      guild.id,
+      commandName
+    )
+
+  if (availableChannels.length && !availableChannels.includes(channel.id)) {
+    const channelNames = availableChannels.map((c) => `<#${c}> `)
+    const reply = `You can only run this command inside of the following channels: ${channelNames}.`
+
+    if (message) message.reply(reply)
+    else if (interaction) interaction.reply(reply)
+
+    return false
+  }
+
+  return true
+}

package/src/command-handler/validations/run-time/disabled-commands.js

@@ -0,0 +1,21 @@
+module.exports = async (command, usage) => {
+  const { commandName, instance } = command
+  const { guild, message, interaction } = usage
+
+  if (!guild) {
+    return true
+  }
+
+  if (
+    instance.commandHandler.disabledCommands.isDisabled(guild.id, commandName)
+  ) {
+    const text = 'This command is disabled'
+
+    if (message) message.channel.send(text)
+    else if (interaction) interaction.reply(text)
+
+    return false
+  }
+
+  return true
+}

package/src/command-handler/validations/run-time/guild-only.js

@@ -0,0 +1,15 @@
+module.exports = (command, usage) => {
+  const { guildOnly } = command.commandObject
+  const { guild, message, interaction } = usage
+
+  if (guildOnly === true && !guild) {
+    const text = 'This command can only be ran within a guild/server.'
+
+    if (message) message.reply(text)
+    else if (interaction) interaction.reply(text)
+
+    return false
+  }
+
+  return true
+}

package/src/command-handler/validations/run-time/has-permissions.js

@@ -0,0 +1,50 @@
+const { PermissionFlagsBits } = require('discord.js')
+const requiredPermissions = require('../../../models/required-permissions-schema')
+
+const keys = Object.keys(PermissionFlagsBits)
+
+module.exports = async (command, usage) => {
+  const { permissions = [] } = command.commandObject
+  const { guild, member, message, interaction } = usage
+
+  if (!member) {
+    return true
+  }
+
+  const document = await requiredPermissions.findById(
+    `${guild.id}-${command.commandName}`
+  )
+  if (document) {
+    for (const permission of document.permissions) {
+      if (!permissions.includes(permission)) {
+        permissions.push(permission)
+      }
+    }
+  }
+
+  if (permissions.length) {
+    const missingPermissions = []
+
+    for (const permission of permissions) {
+      if (!member.permissions.has(permission)) {
+        const permissionName = keys.find(
+          (key) => key === permission || PermissionFlagsBits[key] === permission
+        )
+        missingPermissions.push(permissionName)
+      }
+    }
+
+    if (missingPermissions.length) {
+      const text = `You are missing the following permissions: "${missingPermissions.join(
+        '", "'
+      )}"`
+
+      if (message) message.reply(text)
+      else if (interaction) interaction.reply(text)
+
+      return false
+    }
+  }
+
+  return true
+}

package/src/command-handler/validations/run-time/has-roles.js

@@ -0,0 +1,43 @@
+const requiredRoles = require('../../../models/required-roles-schema')
+
+module.exports = async (command, usage) => {
+  const { guild, member, message, interaction } = usage
+
+  if (!member) {
+    return true
+  }
+
+  const _id = `${guild.id}-${command.commandName}`
+  const document = await requiredRoles.findById(_id)
+
+  if (document) {
+    let hasRole = false
+
+    for (const roleId of document.roles) {
+      if (member.roles.cache.has(roleId)) {
+        hasRole = true
+        break
+      }
+    }
+
+    if (hasRole) {
+      return true
+    }
+
+    const reply = {
+      content: `You need one of these roles: ${document.roles.map(
+        (roleId) => `<@&${roleId}>`
+      )}`,
+      allowedMentions: {
+        roles: [],
+      },
+    }
+
+    if (message) message.reply(reply)
+    else if (interaction) interaction.reply(reply)
+
+    return false
+  }
+
+  return true
+}

package/src/command-handler/validations/run-time/owner-only.js

@@ -0,0 +1,12 @@
+module.exports = (command, usage) => {
+  const { instance, commandObject } = command
+  const { botOwners } = instance
+  const { ownerOnly } = commandObject
+  const { user } = usage
+
+  if (ownerOnly === true && !botOwners.includes(user.id)) {
+    return false
+  }
+
+  return true
+}

package/src/command-handler/validations/run-time/test-only.js

@@ -0,0 +1,10 @@
+module.exports = (command, usage) => {
+  const { instance, commandObject } = command
+  const { guild } = usage
+
+  if (commandObject.testOnly !== true) {
+    return true
+  }
+
+  return instance.testServers.includes(guild?.id)
+}

package/src/command-handler/validations/runtime/argument-count.js

@@ -0,0 +1,24 @@
+module.exports = (command, usage, prefix) => {
+  const {
+    minArgs = 0,
+    maxArgs = -1,
+    correctSyntax,
+    expectedArgs = '',
+  } = command.commandObject
+  const { length } = usage.args
+
+  if (length < minArgs || (length > maxArgs && maxArgs !== -1)) {
+    const text = correctSyntax
+      .replace('{PREFIX}', prefix)
+      .replace('{ARGS}', expectedArgs)
+
+    const { message, interaction } = usage
+
+    if (message) message.reply(text)
+    else if (interaction) interaction.reply(text)
+
+    return false
+  }
+
+  return true
+}

package/src/command-handler/validations/runtime/channel-command.js

@@ -0,0 +1,26 @@
+module.exports = async (command, usage) => {
+  const { commandName, instance } = command
+  const { guild, channel, message, interaction } = usage
+
+  if (!guild) {
+    return true
+  }
+
+  const availableChannels =
+    await instance.commandHandler.channelCommands.getAvailableChannels(
+      guild.id,
+      commandName
+    )
+
+  if (availableChannels.length && !availableChannels.includes(channel.id)) {
+    const channelNames = availableChannels.map((c) => `<#${c}> `)
+    const reply = `You can only run this command inside of the following channels: ${channelNames}.`
+
+    if (message) message.reply(reply)
+    else if (interaction) interaction.reply(reply)
+
+    return false
+  }
+
+  return true
+}

package/src/command-handler/validations/runtime/disabled-commands.js

@@ -0,0 +1,21 @@
+module.exports = async (command, usage) => {
+  const { commandName, instance } = command
+  const { guild, message, interaction } = usage
+
+  if (!guild) {
+    return true
+  }
+
+  if (
+    instance.commandHandler.disabledCommands.isDisabled(guild.id, commandName)
+  ) {
+    const text = 'This command is disabled'
+
+    if (message) message.channel.send(text)
+    else if (interaction) interaction.reply(text)
+
+    return false
+  }
+
+  return true
+}

package/src/command-handler/validations/runtime/guild-only.js

@@ -0,0 +1,15 @@
+module.exports = (command, usage) => {
+  const { guildOnly } = command.commandObject
+  const { guild, message, interaction } = usage
+
+  if (guildOnly === true && !guild) {
+    const text = 'This command can only be ran within a guild/server.'
+
+    if (message) message.reply(text)
+    else if (interaction) interaction.reply(text)
+
+    return false
+  }
+
+  return true
+}

package/src/command-handler/validations/runtime/has-permissions.js

@@ -0,0 +1,50 @@
+const { PermissionFlagsBits } = require('discord.js')
+const requiredPermissions = require('../../../models/required-permissions-schema')
+
+const keys = Object.keys(PermissionFlagsBits)
+
+module.exports = async (command, usage) => {
+  const { permissions = [] } = command.commandObject
+  const { guild, member, message, interaction } = usage
+
+  if (!member) {
+    return true
+  }
+
+  const document = await requiredPermissions.findById(
+    `${guild.id}-${command.commandName}`
+  )
+  if (document) {
+    for (const permission of document.permissions) {
+      if (!permissions.includes(permission)) {
+        permissions.push(permission)
+      }
+    }
+  }
+
+  if (permissions.length) {
+    const missingPermissions = []
+
+    for (const permission of permissions) {
+      if (!member.permissions.has(permission)) {
+        const permissionName = keys.find(
+          (key) => key === permission || PermissionFlagsBits[key] === permission
+        )
+        missingPermissions.push(permissionName)
+      }
+    }
+
+    if (missingPermissions.length) {
+      const text = `You are missing the following permissions: "${missingPermissions.join(
+        '", "'
+      )}"`
+
+      if (message) message.reply(text)
+      else if (interaction) interaction.reply(text)
+
+      return false
+    }
+  }
+
+  return true
+}