spacecommands 1.0.0

package/dist/command-checks/guild-only-check.js

@@ -0,0 +1,24 @@
+"use strict";
+module.exports = (guild, command, instance, member, user, reply) => {
+    const { guildOnly } = command;
+    // If this command doesn't care if it's in a guild or not then just simply return true
+    if (!guildOnly) {
+        return true;
+    }
+    if (!guild) {
+        reply(instance.messageHandler.get(guild, 'GUILD_ONLY_COMMAND')).then((message) => {
+            if (!message) {
+                return;
+            }
+            if (instance.delErrMsgCooldown === -1 || !message.deletable) {
+                return;
+            }
+            setTimeout(() => {
+                message.delete();
+            }, 1000 * instance.delErrMsgCooldown);
+        });
+        return false;
+    }
+    // The guild exists
+    return true;
+};

package/dist/command-checks/has-entitlement.js

@@ -0,0 +1,52 @@
+"use strict";
+module.exports = async (guild, command, instance, member, user, reply) => {
+    const { requiredEntitlements, premiumOnly } = command;
+    // If no entitlements are required, allow the command
+    if (!requiredEntitlements.length && !premiumOnly) {
+        return true;
+    }
+    const entitlementHandler = instance.entitlementHandler;
+    if (!entitlementHandler) {
+        console.warn('SpaceCommands > Command requires entitlements but EntitlementHandler is not initialized.');
+        return true;
+    }
+    // Check if user has required entitlements
+    if (requiredEntitlements.length > 0) {
+        const { hasEntitlement } = await entitlementHandler.hasAnyEntitlement(user.id, requiredEntitlements);
+        if (!hasEntitlement) {
+            reply(instance.messageHandler.get(guild, 'MISSING_ENTITLEMENT') ||
+                'You need a premium subscription to use this command.').then((message) => {
+                if (!message) {
+                    return;
+                }
+                if (instance.delErrMsgCooldown === -1 || !message.deletable) {
+                    return;
+                }
+                setTimeout(() => {
+                    message.delete();
+                }, 1000 * instance.delErrMsgCooldown);
+            });
+            return false;
+        }
+    }
+    // If premiumOnly is set, check for any active entitlement
+    if (premiumOnly) {
+        const allEntitlements = await entitlementHandler.getUserEntitlements(user.id);
+        if (allEntitlements.length === 0) {
+            reply(instance.messageHandler.get(guild, 'PREMIUM_ONLY') ||
+                'This command is only available to premium subscribers.').then((message) => {
+                if (!message) {
+                    return;
+                }
+                if (instance.delErrMsgCooldown === -1 || !message.deletable) {
+                    return;
+                }
+                setTimeout(() => {
+                    message.delete();
+                }, 1000 * instance.delErrMsgCooldown);
+            });
+            return false;
+        }
+    }
+    return true;
+};

package/dist/command-checks/has-permissions.js

@@ -0,0 +1,39 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+const CommandErrors_1 = __importDefault(require("../enums/CommandErrors"));
+module.exports = (guild, command, instance, member, user, reply) => {
+    if (!guild || !member) {
+        return true;
+    }
+    const { requiredPermissions, error } = command;
+    for (const perm of requiredPermissions || []) {
+        // @ts-ignore
+        if (!member.permissions.has(perm)) {
+            if (error) {
+                error({
+                    error: CommandErrors_1.default.MISSING_PERMISSIONS,
+                    command,
+                });
+            }
+            else {
+                reply(instance.messageHandler.get(guild, 'MISSING_PERMISSION', {
+                    PERM: perm,
+                })).then((message) => {
+                    if (!message) {
+                        return;
+                    }
+                    if (instance.delErrMsgCooldown === -1 || !message.deletable) {
+                        return;
+                    }
+                    setTimeout(() => {
+                        message.delete();
+                    }, 1000 * instance.delErrMsgCooldown);
+                });
+            }
+            return false;
+        }
+    }
+    return true;
+};

package/dist/command-checks/has-roles.js

@@ -0,0 +1,69 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+const CommandErrors_1 = __importDefault(require("../enums/CommandErrors"));
+module.exports = async (guild, command, instance, member, user, reply) => {
+    if (!guild || !member) {
+        return true;
+    }
+    const { error } = command;
+    const roles = command.getRequiredRoles(guild.id);
+    if (roles && roles.length) {
+        const missingRoles = [];
+        const missingRolesNames = [];
+        for (const role of roles) {
+            const realRole = await guild.roles.fetch(role);
+            if (realRole !== null && !member.roles.cache.has(role)) {
+                missingRoles.push(role);
+                missingRolesNames.push(realRole.name);
+            }
+        }
+        if (missingRoles.length) {
+            if (error) {
+                error({
+                    error: CommandErrors_1.default.MISSING_ROLES,
+                    command,
+                    message: null,
+                    info: {
+                        missingRoles,
+                    },
+                });
+            }
+            else {
+                reply(instance.messageHandler.get(guild, 'MISSING_ROLES', {
+                    ROLES: missingRolesNames.join(', '),
+                })).then((message) => {
+                    if (!message) {
+                        return;
+                    }
+                    if (instance.delErrMsgCooldown === -1 || !message.deletable) {
+                        return;
+                    }
+                    setTimeout(() => {
+                        message.delete();
+                    }, 1000 * instance.delErrMsgCooldown);
+                });
+            }
+            return false;
+        }
+    }
+    else if (command.doesRequireRoles) {
+        reply(instance.messageHandler.get(guild, 'REQUIRE_ROLES', {
+            PREFIX: instance.getPrefix(guild),
+            COMMAND: command.names[0],
+        })).then((message) => {
+            if (!message) {
+                return;
+            }
+            if (instance.delErrMsgCooldown === -1 || !message.deletable) {
+                return;
+            }
+            setTimeout(() => {
+                message.delete();
+            }, 1000 * instance.delErrMsgCooldown);
+        });
+        return false;
+    }
+    return true;
+};

package/dist/command-checks/has-valid-arguments.js

@@ -0,0 +1,54 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+const CommandErrors_1 = __importDefault(require("../enums/CommandErrors"));
+module.exports = (guild, command, instance, member, user, reply, args, name) => {
+    const { minArgs, maxArgs, expectedArgs, error } = command;
+    const prefix = instance.getPrefix(guild).toLowerCase();
+    if ((minArgs !== undefined && args.length < minArgs) ||
+        (maxArgs !== undefined && maxArgs !== -1 && args.length > maxArgs)) {
+        const syntaxError = command.syntaxError || {};
+        const { messageHandler } = instance;
+        let errorMsg = syntaxError[messageHandler.getLanguage(guild)] ||
+            instance.messageHandler.get(guild, 'SYNTAX_ERROR');
+        // Replace {PREFIX} with the actual prefix
+        if (errorMsg) {
+            errorMsg = errorMsg.replace(/{PREFIX}/g, prefix);
+            // Replace {COMMAND} with the name of the command that was ran
+            errorMsg = errorMsg.replace(/{COMMAND}/g, name);
+            // Replace {ARGUMENTS} with the expectedArgs property from the command
+            // If one was not provided then replace {ARGUMENTS} with an empty string
+            errorMsg = errorMsg.replace(/ {ARGUMENTS}/g, expectedArgs ? ` ${expectedArgs}` : '');
+        }
+        if (error) {
+            error({
+                error: CommandErrors_1.default.INVALID_ARGUMENTS,
+                command,
+                message: null,
+                info: {
+                    minArgs,
+                    maxArgs,
+                    length: args.length,
+                    errorMsg,
+                },
+            });
+        }
+        else {
+            // Reply with the local or global syntax error
+            reply(errorMsg).then((message) => {
+                if (!message) {
+                    return;
+                }
+                if (instance.delErrMsgCooldown === -1 || !message.deletable) {
+                    return;
+                }
+                setTimeout(() => {
+                    message.delete();
+                }, 1000 * instance.delErrMsgCooldown);
+            });
+        }
+        return false;
+    }
+    return true;
+};

package/dist/command-checks/in-cooldown.js

@@ -0,0 +1,42 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+const CommandErrors_1 = __importDefault(require("../enums/CommandErrors"));
+module.exports = (guild, command, instance, member, user, reply) => {
+    const { cooldown, globalCooldown, error } = command;
+    if ((cooldown || globalCooldown) && user) {
+        const guildId = guild ? guild.id : 'dm';
+        const timeLeft = command.getCooldownSeconds(guildId, user.id);
+        if (timeLeft) {
+            if (error) {
+                error({
+                    error: CommandErrors_1.default.COOLDOWN,
+                    command,
+                    message: null,
+                    info: {
+                        timeLeft,
+                    },
+                });
+            }
+            else {
+                reply(instance.messageHandler.get(guild, 'COOLDOWN', {
+                    COOLDOWN: timeLeft,
+                })).then((message) => {
+                    if (!message) {
+                        return;
+                    }
+                    if (instance.delErrMsgCooldown === -1 || !message.deletable) {
+                        return;
+                    }
+                    setTimeout(() => {
+                        message.delete();
+                    }, 1000 * instance.delErrMsgCooldown);
+                });
+            }
+            return false;
+        }
+        command.setCooldown(guildId, user.id);
+    }
+    return true;
+};

package/dist/command-checks/is-enabled.js

@@ -0,0 +1,31 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+const CommandErrors_1 = __importDefault(require("../enums/CommandErrors"));
+module.exports = (guild, command, instance, member, user, reply) => {
+    if (!guild || !command.isDisabled(guild.id)) {
+        return true;
+    }
+    const { error } = command;
+    if (error) {
+        error({
+            error: CommandErrors_1.default.COMMAND_DISABLED,
+            command,
+        });
+    }
+    else {
+        reply(instance.messageHandler.get(guild, 'DISABLED_COMMAND')).then((message) => {
+            if (!message) {
+                return;
+            }
+            if (instance.delErrMsgCooldown === -1 || !message.deletable) {
+                return;
+            }
+            setTimeout(() => {
+                message.delete();
+            }, 1000 * instance.delErrMsgCooldown);
+        });
+    }
+    return false;
+};

package/dist/command-checks/is-not-test-only.js

@@ -0,0 +1,8 @@
+"use strict";
+module.exports = (guild, command, instance) => {
+    const { testOnly } = command;
+    if (!testOnly) {
+        return true;
+    }
+    return guild && instance.testServers.includes(guild.id);
+};

package/dist/command-checks/owner-only-check.js

@@ -0,0 +1,22 @@
+"use strict";
+module.exports = (guild, command, instance, member, user, reply) => {
+    const { ownerOnly } = command;
+    if (!ownerOnly) {
+        return true;
+    }
+    if (!instance.botOwner.includes(user.id)) {
+        reply(instance.messageHandler.get(guild, 'BOT_OWNERS_ONLY')).then((message) => {
+            if (!message) {
+                return;
+            }
+            if (instance.delErrMsgCooldown === -1 || !message.deletable) {
+                return;
+            }
+            setTimeout(() => {
+                message.delete();
+            }, 1000 * instance.delErrMsgCooldown);
+        });
+        return false;
+    }
+    return true;
+};

package/dist/commands/channelonly.js

@@ -0,0 +1,88 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+const channel_commands_1 = __importDefault(require("../models/channel-commands"));
+module.exports = {
+    description: 'Makes a command only work in some channels.',
+    category: 'Configuration',
+    permissions: ['Administrator'],
+    minArgs: 1,
+    maxArgs: 2,
+    expectedArgs: '<Command name> [Channel tag]',
+    cooldown: '2s',
+    guildOnly: true,
+    slash: 'both',
+    options: [
+        {
+            name: 'command',
+            description: 'The command name',
+            type: 'STRING',
+            required: true,
+        },
+        {
+            name: 'channel',
+            description: 'The tag of the channel',
+            type: 'CHANNEL',
+            required: false,
+        },
+    ],
+    callback: async (options) => {
+        const { message, channel, args, instance, interaction } = options;
+        const { guild } = channel;
+        const { messageHandler } = instance;
+        let commandName = (args.shift() || '').toLowerCase();
+        const command = instance.commandHandler.getCommand(commandName);
+        if (!instance.isDBConnected()) {
+            return messageHandler.get(guild, 'NO_DATABASE_FOUND');
+        }
+        if (!command || !command.names) {
+            return messageHandler.get(guild, 'UNKNOWN_COMMAND', {
+                COMMAND: commandName,
+            });
+        }
+        commandName = command.names[0];
+        if (args.length === 0) {
+            const results = await channel_commands_1.default.deleteMany({
+                guildId: guild?.id,
+                command: commandName,
+            });
+            // @ts-ignore
+            if (results.n === 0) {
+                return messageHandler.get(guild, 'NOT_CHANNEL_COMMAND');
+            }
+            command.setRequiredChannels(guild, commandName, []);
+            return messageHandler.get(guild, 'NO_LONGER_CHANNEL_COMMAND');
+        }
+        if (message?.mentions.channels.size === 0) {
+            return messageHandler.get(guild, 'NO_TAGGED_CHANNELS');
+        }
+        let channels;
+        if (message) {
+            channels = Array.from(message.mentions.channels.keys());
+        }
+        else {
+            channels = [interaction.options.getChannel('channel')];
+        }
+        const results = await channel_commands_1.default.findOneAndUpdate({
+            guildId: guild?.id,
+            command: commandName,
+        }, {
+            guildId: guild?.id,
+            command: commandName,
+            $addToSet: {
+                channels,
+            },
+        }, {
+            upsert: true,
+            new: true,
+        });
+        if (results) {
+            command.setRequiredChannels(guild, commandName, results.channels);
+        }
+        return messageHandler.get(guild, 'NOW_CHANNEL_COMMAND', {
+            COMMAND: commandName,
+            CHANNELS: args.join(' '),
+        });
+    },
+};

package/dist/commands/command.js

@@ -0,0 +1,87 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+// @ts-nocheck
+const disabled_commands_1 = __importDefault(require("../models/disabled-commands"));
+module.exports = {
+    description: 'Enables or disables a command for this guild',
+    category: 'Configuration',
+    permissions: ['Administrator'],
+    minArgs: 2,
+    maxArgs: 2,
+    expectedArgs: '<"enable" or "disable"> <Command Name>',
+    cooldown: '2s',
+    slash: 'both',
+    options: [
+        {
+            name: 'action',
+            description: 'Either "enable" or "disable"',
+            required: true,
+            type: 'STRING',
+            choices: [
+                {
+                    name: 'Enable',
+                    value: 'enable',
+                },
+                { name: 'Disable', value: 'disable' },
+            ],
+        },
+        {
+            name: 'command',
+            description: 'The name of the command',
+            required: true,
+            type: 'STRING',
+        },
+    ],
+    callback: async (options) => {
+        const { channel, args, instance } = options;
+        const { guild } = channel;
+        const newState = args.shift()?.toLowerCase();
+        const name = (args.shift() || '').toLowerCase();
+        if (!guild) {
+            return instance.messageHandler.get(guild, 'CANNOT_ENABLE_DISABLE_IN_DMS');
+        }
+        if (!instance.isDBConnected()) {
+            return instance.messageHandler.get(guild, 'NO_DATABASE_FOUND');
+        }
+        if (newState !== 'enable' && newState !== 'disable') {
+            return instance.messageHandler.get(guild, 'ENABLE_DISABLE_STATE');
+        }
+        const command = instance.commandHandler.getCommand(name);
+        if (command) {
+            const mainCommand = command.names[0];
+            if (mainCommand === 'command') {
+                return instance.messageHandler.get(guild, 'CANNOT_DISABLE_THIS_COMMAND');
+            }
+            const isDisabled = command.isDisabled(guild.id);
+            if (newState === 'enable') {
+                if (!isDisabled) {
+                    return instance.messageHandler.get(guild, 'COMMAND_ALREADY_ENABLED');
+                }
+                await disabled_commands_1.default.deleteOne({
+                    guildId: guild.id,
+                    command: mainCommand,
+                });
+                command.enable(guild.id);
+                return instance.messageHandler.get(guild, 'COMMAND_NOW_ENABLED', {
+                    COMMAND: mainCommand,
+                });
+            }
+            if (isDisabled) {
+                return instance.messageHandler.get(guild, 'COMMAND_ALREADY_DISABLED');
+            }
+            await new disabled_commands_1.default({
+                guildId: guild.id,
+                command: mainCommand,
+            }).save();
+            command.disable(guild.id);
+            return instance.messageHandler.get(guild, 'COMMAND_NOW_DISABLED', {
+                COMMAND: mainCommand,
+            });
+        }
+        return instance.messageHandler.get(guild, 'UNKNOWN_COMMAND', {
+            COMMAND: name,
+        });
+    },
+};