nv-kit 1.0.0

package/src/command-handler/validations/runtime/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/runtime/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/runtime/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/syntax/bad-cooldown-types.js

@@ -0,0 +1,28 @@
+const { cooldownTypes } = require('../../../util/Cooldowns')
+
+module.exports = (command) => {
+  const { commandObject, commandName } = command
+
+  if (!commandObject.cooldowns) {
+    return
+  }
+
+  let counter = 0
+  for (const type of cooldownTypes) {
+    if (commandObject.cooldowns[type]) {
+      ++counter
+    }
+  }
+
+  if (counter === 0) {
+    throw new Error(
+      `Command "${commandName}" does have a cooldown object, but no cooldown types were specified. Please use one of the following: ${cooldownTypes}`
+    )
+  }
+
+  if (counter > 1) {
+    throw new Error(
+      `Command "${commandName}" has multiple cooldown types, you must specify only one.`
+    )
+  }
+}

package/src/command-handler/validations/syntax/callback-required.js

@@ -0,0 +1,9 @@
+module.exports = (command) => {
+  const { commandObject, commandName } = command
+
+  if (!commandObject.callback) {
+    throw new Error(
+      `Command "${commandName}" does not have a callback function.`
+    )
+  }
+}

package/src/command-handler/validations/syntax/defer-reply.js

@@ -0,0 +1,14 @@
+module.exports = (command) => {
+  const { commandObject, commandName } = command
+  const { deferReply } = commandObject
+
+  if (
+    deferReply &&
+    typeof deferReply !== 'boolean' &&
+    deferReply !== 'ephemeral'
+  ) {
+    throw new Error(
+      `Command "${commandName}" does not have a valid value for "deferReply". Please use a boolean value or the string "ephemeral".`
+    )
+  }
+}

package/src/command-handler/validations/syntax/desc-required-for-slash.js

@@ -0,0 +1,11 @@
+module.exports = (command) => {
+  const { commandName, commandObject } = command
+
+  if (commandObject.slash === true || commandObject.slash === 'both') {
+    if (!commandObject.description) {
+      throw new Error(
+        `Command "${commandName}" is a slash command but does not have a description`
+      )
+    }
+  }
+}

package/src/command-handler/validations/syntax/owner-only-without-owners.js

@@ -0,0 +1,11 @@
+module.exports = (command) => {
+  const { instance, commandName, commandObject } = command
+
+  if (commandObject.ownerOnly !== true || instance.botOwners.length) {
+    return
+  }
+
+  throw new Error(
+    `Command "${commandName}" is a owner only command, but no owners were specified.`
+  )
+}

package/src/command-handler/validations/syntax/permissions-without-guild-only.js

@@ -0,0 +1,10 @@
+module.exports = (command) => {
+  const { commandObject, commandName } = command
+  const { guildOnly, permissions = [] } = commandObject
+
+  if (guildOnly !== true && permissions.length) {
+    throw new Error(
+      `Command "${commandName}" is not a guildOnly command, but permissions are specified.`
+    )
+  }
+}

package/src/command-handler/validations/syntax/test-without-server.js

@@ -0,0 +1,11 @@
+module.exports = (command) => {
+  const { instance, commandName, commandObject } = command
+
+  if (commandObject.testOnly !== true || instance.testServers.length) {
+    return
+  }
+
+  throw new Error(
+    `Command "${commandName}" is a test only command, but no test servers were specified.`
+  )
+}

package/src/event-handler/EventHandler.js

@@ -0,0 +1,87 @@
+const { InteractionType } = require('discord.js')
+const path = require('path')
+
+const getAllFiles = require('../util/get-all-files')
+
+class EventHandler {
+  // <eventName, array of [function, dynamic validation functions]>
+  _eventCallbacks = new Map()
+
+  constructor(instance, events, client) {
+    this._instance = instance
+    this._eventsDir = events?.dir
+    this._client = client
+
+    delete events.dir
+    this._events = events
+
+    this._builtInEvents = {
+      interactionCreate: {
+        isButton: (interaction) => interaction.isButton(),
+        isCommand: (interaction) =>
+          interaction.type === InteractionType.ApplicationCommand || interaction.type === InteractionType.ApplicationCommandAutocomplete,
+      },
+      messageCreate: {
+        isHuman: (message) => !message.author.bot,
+      },
+    }
+
+    this.readFiles()
+    this.registerEvents()
+  }
+
+  async readFiles() {
+    const defaultEvents = getAllFiles(path.join(__dirname, 'events'), true)
+    const folders = this._eventsDir ? getAllFiles(this._eventsDir, true) : []
+
+    for (const folderPath of [...defaultEvents, ...folders]) {
+      const event = folderPath.split(/[\/\\]/g).pop()
+      const files = getAllFiles(folderPath)
+
+      const functions = this._eventCallbacks.get(event) || []
+
+      for (const file of files) {
+        const isBuiltIn = !folderPath.includes(this._eventsDir)
+        const func = require(file)
+        const result = [func]
+
+        const split = file.split(event)[1].split(/[\/\\]/g)
+        const methodName = split[split.length - 2]
+
+        if (
+          isBuiltIn &&
+          this._builtInEvents[event] &&
+          this._builtInEvents[event][methodName]
+        ) {
+          result.push(this._builtInEvents[event][methodName])
+        } else if (this._events[event] && this._events[event][methodName]) {
+          result.push(this._events[event][methodName])
+        }
+
+        functions.push(result)
+      }
+
+      this._eventCallbacks.set(event, functions)
+    }
+  }
+
+  registerEvents() {
+    const instance = this._instance
+
+    for (const eventName of this._eventCallbacks.keys()) {
+      const functions = this._eventCallbacks.get(eventName)
+
+      this._client.on(eventName, async function () {
+        for (const [func, dynamicValidation] of functions) {
+          if (dynamicValidation && !(await dynamicValidation(...arguments))) {
+            continue
+          }
+
+          func(...arguments, instance)
+        }
+      })
+    }
+  }
+}
+
+module.exports = EventHandler

package/src/event-handler/events/interactionCreate/isButton/test.js

@@ -0,0 +1,3 @@
+module.exports = (interaction) => {
+  interaction.reply('testing')
+}

package/src/event-handler/events/interactionCreate/isCommand/slash-commands.js

@@ -0,0 +1,77 @@
+const { InteractionType } = require('discord.js')
+
+const handleAutocomplete = async (interaction, commands) => {
+  const command = commands.get(interaction.commandName)
+  if (!command) {
+    return
+  }
+
+  const { autocomplete } = command.commandObject
+  if (!autocomplete) {
+    return
+  }
+
+  const focusedOption = interaction.options.getFocused(true)
+  const choices = await autocomplete(interaction, command, focusedOption.name)
+
+  const filtered = choices
+    .filter((choice) =>
+      choice.toLowerCase().startsWith(focusedOption.value.toLowerCase())
+    )
+    .slice(0, 25)
+
+  await interaction.respond(
+    filtered.map((choice) => ({
+      name: choice,
+      value: choice,
+    }))
+  )
+}
+
+module.exports = async (interaction, instance) => {
+  const { commandHandler } = instance
+  const { commands, customCommands } = commandHandler
+
+  if (interaction.type === InteractionType.ApplicationCommandAutocomplete) {
+    handleAutocomplete(interaction, commands)
+    return
+  }
+
+  if (interaction.type !== InteractionType.ApplicationCommand) {
+    return
+  }
+
+  const args = interaction.options.data.map(({ value }) => {
+    return String(value)
+  })
+
+  const command = commands.get(interaction.commandName)
+  if (!command) {
+    customCommands.run(interaction.commandName, null, interaction)
+    return
+  }
+
+  const { deferReply } = command.commandObject
+
+  if (deferReply) {
+    await interaction.deferReply({
+      ephemeral: deferReply === 'ephemeral',
+    })
+  }
+
+  const response = await commandHandler.runCommand(
+    command,
+    args,
+    null,
+    interaction
+  )
+  if (!response) {
+    return
+  }
+
+  if (deferReply) {
+    interaction.editReply(response).catch(() => {})
+  } else {
+    interaction.reply(response).catch(() => {})
+  }
+}

package/src/event-handler/events/messageCreate/isHuman/legacy-commands.js

@@ -0,0 +1,36 @@
+module.exports = async (message, instance) => {
+  const { guild, content } = message
+  const { commandHandler } = instance
+  const { prefixHandler, commands, customCommands } = commandHandler
+
+  const prefix = prefixHandler.get(guild?.id)
+  if (!content.startsWith(prefix)) {
+    return
+  }
+
+  const args = content.split(/\s+/)
+  const commandName = args.shift().substring(prefix.length).toLowerCase()
+
+  const command = commands.get(commandName)
+  if (!command) {
+    customCommands.run(commandName, message)
+    return
+  }
+
+  const { reply, deferReply } = command.commandObject
+
+  if (deferReply) {
+    message.channel.sendTyping()
+  }
+
+  const response = await commandHandler.runCommand(command, args, message)
+  if (!response) {
+    return
+  }
+
+  if (reply) {
+    message.reply(response).catch(() => {})
+  } else {
+    message.channel.send(response).catch(() => {})
+  }
+}

package/src/index.js

@@ -0,0 +1,90 @@
+const mongoose = require('mongoose')
+
+const CommandHandler = require('./command-handler/CommandHandler')
+const Cooldowns = require('./util/Cooldowns')
+const EventHandler = require('./event-handler/EventHandler')
+const FeatureHandler = require('./util/FeatureHandler')
+
+class Main {
+  constructor(obj) {
+    this.init(obj)
+  }
+
+  async init({
+    client,
+    mongoUri,
+    commandsDir,
+    featuresDir,
+    testServers = [],
+    botOwners = [],
+    cooldownConfig = {},
+    disabledDefaultCommands = [],
+    events = {},
+    validations = {},
+  }) {
+    if (!client) {
+      throw new Error('A client is required.')
+    }
+
+    this._testServers = testServers
+    this._botOwners = botOwners
+    this._cooldowns = new Cooldowns({
+      instance: this,
+      ...cooldownConfig,
+    })
+    this._disabledDefaultCommands = disabledDefaultCommands.map((cmd) =>
+      cmd.toLowerCase()
+    )
+    this._validations = validations
+
+    if (mongoUri) {
+      await this.connectToMongo(mongoUri)
+    }
+
+    if (commandsDir) {
+      this._commandHandler = new CommandHandler(this, commandsDir, client)
+    }
+
+    if (featuresDir) {
+      new FeatureHandler(this, featuresDir, client)
+    }
+
+    this._eventHandler = new EventHandler(this, events, client)
+  }
+
+  get testServers() {
+    return this._testServers
+  }
+
+  get botOwners() {
+    return this._botOwners
+  }
+
+  get cooldowns() {
+    return this._cooldowns
+  }
+
+  get disabledDefaultCommands() {
+    return this._disabledDefaultCommands
+  }
+
+  get commandHandler() {
+    return this._commandHandler
+  }
+
+  get eventHandler() {
+    return this._eventHandler
+  }
+
+  get validations() {
+    return this._validations
+  }
+
+  async connectToMongo(mongoUri) {
+    await mongoose.connect(mongoUri, {
+      keepAlive: true,
+    })
+  }
+}
+
+module.exports = Main

package/src/models/channel-commands-schema.js

@@ -0,0 +1,16 @@
+const { Schema, model, models } = require('mongoose')
+
+const channelCommandSchema = new Schema({
+  // guildId-commandName
+  _id: {
+    type: String,
+    required: true,
+  },
+  channels: {
+    type: [String],
+    required: true,
+  },
+})
+
+const name = 'channel-commands'
+module.exports = models[name] || model(name, channelCommandSchema)

package/src/models/cooldown-schema.js

@@ -0,0 +1,16 @@
+const { Schema, model, models } = require('mongoose')
+
+const cooldownSchema = new Schema({
+  // The key from Cooldowns.getKey()
+  _id: {
+    type: String,
+    required: true,
+  },
+  expires: {
+    type: Date,
+    required: true,
+  },
+})
+
+const name = 'cooldowns'
+module.exports = models[name] || model(name, cooldownSchema)

package/src/models/custom-command-schema.js

@@ -0,0 +1,16 @@
+const { Schema, model, models } = require('mongoose')
+
+const customCommandSchema = new Schema({
+  // guildId-commandName
+  _id: {
+    type: String,
+    required: true,
+  },
+  response: {
+    type: String,
+    required: true,
+  },
+})
+
+const name = 'custom-commands'
+module.exports = models[name] || model(name, customCommandSchema)

package/src/models/disabled-commands-schema.js

@@ -0,0 +1,12 @@
+const { Schema, model, models } = require('mongoose')
+
+const disabledCommandSchema = new Schema({
+  // guildId-commandName
+  _id: {
+    type: String,
+    required: true,
+  },
+})
+
+const name = 'disabled-commands'
+module.exports = models[name] || model(name, disabledCommandSchema)

package/src/models/guild-prefix-schema.js

@@ -0,0 +1,16 @@
+const { Schema, model, models } = require('mongoose')
+
+const guildPrefixSchema = new Schema({
+  // guild ID
+  _id: {
+    type: String,
+    required: true,
+  },
+  prefix: {
+    type: String,
+    required: true,
+  },
+})
+
+const name = 'guild-prefixes'
+module.exports = models[name] || model(name, guildPrefixSchema)

package/src/models/required-permissions-schema.js

@@ -0,0 +1,16 @@
+const { Schema, model, models } = require('mongoose')
+
+const requiredPermissionsSchema = new Schema({
+  // guildId-commandName
+  _id: {
+    type: String,
+    required: true,
+  },
+  permissions: {
+    type: [String],
+    required: true,
+  },
+})
+
+const name = 'required-permissions'
+module.exports = models[name] || model(name, requiredPermissionsSchema)

package/src/models/required-roles-schema.js

@@ -0,0 +1,16 @@
+const { Schema, model, models } = require('mongoose')
+
+const requiredRolesSchema = new Schema({
+  // guildId-commandName
+  _id: {
+    type: String,
+    required: true,
+  },
+  roles: {
+    type: [String],
+    required: true,
+  },
+})
+
+const name = 'required-roles'
+module.exports = models[name] || model(name, requiredRolesSchema)