reciple 3.0.1 → 3.1.0

package/README.md

@@ -1,15 +1,22 @@
 <h1 align="center">
     <img src="https://i.imgur.com/DWM0tJL.png" width="50%">
     <br>
-    <img alt="Lines of code" src="https://img.shields.io/tokei/lines/github/FalloutStudios/Reciple">
-    <img alt="GitHub" src="https://img.shields.io/github/license/FalloutStudios/Reciple">
-    <a href="https://www.codefactor.io/repository/github/falloutstudios/reciple/overview/main"><img src="https://www.codefactor.io/repository/github/falloutstudios/reciple/badge/main" alt="CodeFactor"></a>
 </h1>
 
-A simple Dicord.js command handler that just works.
+<h3 align="center">
+<a href="https://npmjs.org/package/reciple">
+        <img src="https://img.shields.io/npm/v/reciple?label=latest%20npm%20release%20">
+    </a>
+    <a href="https://github.com/FalloutStudios/Reciple/blob/main/LICENSE">
+        <img src="https://img.shields.io/github/license/FalloutStudios/Reciple">
+    </a>
+    <a href="https://www.codefactor.io/repository/github/falloutstudios/reciple/overview/main">
+        <img src="https://www.codefactor.io/repository/github/falloutstudios/reciple/badge/main">
+    </a>
 
-# Join Discord
-[![Discord Invite](https://i.imgur.com/GffJByO.png)](https://discord.gg/2CattJYNpw)
+A simple Dicord.js handler that just works.<h3>
+
+****
 
 ## Installation
 To install the bot, run the following command in your terminal:
@@ -51,6 +58,9 @@ You can override the given token using your terminal
 ```bash
 npx reciple --token "YOUR_TOKEN_HERE"
 ```
+```bash
+npx reciple --token "env:TOKEN_VARIABLE"
+```
 
 ## Starting the bot
 To start the bot, run the following command:
@@ -62,4 +72,10 @@ npx reciple
 > ## Fun Fact
 > The name reciple is from a minecraft bug. The bug was a misspelling of the word `recipe`. [View Mojang Bug Report](https://bugs.mojang.com/browse/MC-225837)
 
+
+# Join Discord
+[![Discord Invite](https://i.imgur.com/GffJByO.png)](https://discord.gg/2CattJYNpw)
+
+****
+
 [#letTheEarthBreathe](https://rebellion.global/)

package/bin/bin.js

@@ -11,12 +11,12 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 var _a, _b;
 Object.defineProperty(exports, "__esModule", { value: true });
-const RecipleConfig_1 = require("./reciple/classes/RecipleConfig");
 const RecipleClient_1 = require("./reciple/classes/RecipleClient");
-const fs_1 = require("fs");
-const version_1 = require("./reciple/version");
+const RecipleConfig_1 = require("./reciple/classes/RecipleConfig");
 const flags_1 = require("./reciple/flags");
+const version_1 = require("./reciple/version");
 const fallout_utility_1 = require("fallout-utility");
+const fs_1 = require("fs");
 require("dotenv/config");
 if (flags_1.flags.version) {
     console.log(`v${version_1.version}`);

package/bin/index.d.ts

@@ -1,16 +1,16 @@
-export * from './reciple/classes/RecipleClient';
-export * from './reciple/classes/RecipleConfig';
 export * from './reciple/classes/CommandCooldownManager';
 export * from './reciple/classes/MessageCommandOptionManager';
+export * from './reciple/classes/RecipleClient';
+export * from './reciple/classes/RecipleConfig';
 export * from './reciple/classes/builders/InteractionCommandBuilder';
 export * from './reciple/classes/builders/MessageCommandBuilder';
 export * from './reciple/classes/builders/MessageCommandOptionBuilder';
 export * from './reciple/types/builders';
 export * from './reciple/types/commands';
 export * from './reciple/types/paramOptions';
-export * from './reciple/permissions';
 export * from './reciple/flags';
 export * from './reciple/logger';
 export * from './reciple/modules';
+export * from './reciple/permissions';
 export * from './reciple/registerInteractionCommands';
 export * from './reciple/version';

package/bin/index.js

@@ -14,19 +14,19 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./reciple/classes/RecipleClient"), exports);
-__exportStar(require("./reciple/classes/RecipleConfig"), exports);
 __exportStar(require("./reciple/classes/CommandCooldownManager"), exports);
 __exportStar(require("./reciple/classes/MessageCommandOptionManager"), exports);
+__exportStar(require("./reciple/classes/RecipleClient"), exports);
+__exportStar(require("./reciple/classes/RecipleConfig"), exports);
 __exportStar(require("./reciple/classes/builders/InteractionCommandBuilder"), exports);
 __exportStar(require("./reciple/classes/builders/MessageCommandBuilder"), exports);
 __exportStar(require("./reciple/classes/builders/MessageCommandOptionBuilder"), exports);
 __exportStar(require("./reciple/types/builders"), exports);
 __exportStar(require("./reciple/types/commands"), exports);
 __exportStar(require("./reciple/types/paramOptions"), exports);
-__exportStar(require("./reciple/permissions"), exports);
 __exportStar(require("./reciple/flags"), exports);
 __exportStar(require("./reciple/logger"), exports);
 __exportStar(require("./reciple/modules"), exports);
+__exportStar(require("./reciple/permissions"), exports);
 __exportStar(require("./reciple/registerInteractionCommands"), exports);
 __exportStar(require("./reciple/version"), exports);

package/bin/reciple/classes/CommandCooldownManager.d.ts

@@ -1,5 +1,8 @@
 import { RecipleCommandBuilderType } from '../types/builders';
 import { Guild, TextBasedChannel, User } from 'discord.js';
+/**
+ * Object interface for cooled-down user
+ */
 export interface CooledDownUser {
     user: User;
     command: string;
@@ -8,29 +11,40 @@ export interface CooledDownUser {
     channel?: TextBasedChannel;
     expireTime: number;
 }
+/**
+ * Stores cooled-down users
+ */
 export declare class CommandCooldownManager extends Array<CooledDownUser> {
     /**
      * Alias for `CommandCooldownManager#push()`
+     * @param options Cooled-down user data
      */
     add(...options: CooledDownUser[]): number;
     /**
      * Remove cooldown from specific user, channel or guild
+     * @param options Remove cooldown data options
+     * @param limit Remove cooldown data limit
      */
     remove(options: Partial<CooledDownUser>, limit?: number): void;
     /**
      * Check if the given user is cooled-down
+     * @param options Options to identify if user is on cooldown
      */
     isCooledDown(options: Partial<Omit<CooledDownUser, 'expireTime'>>): boolean;
     /**
-     * Clear non cooled-down users from this array
+     * Purge non cooled-down users from this array
+     * @param options Clean cooldown options
      */
     clean(options?: Partial<Omit<CooledDownUser, 'expireTime'>>): void;
     /**
      * Get someone's cooldown data
+     * @param options Get cooldown data options
      */
     get(options: Partial<Omit<CooledDownUser, 'expireTime'>>): CooledDownUser | undefined;
     /**
      * Check if the options are valid
+     * @param options Options to validated
+     * @param data Cooled-down user data
      */
     static checkOptions(options: Partial<Omit<CooledDownUser, 'expireTime'>>, data: CooledDownUser): boolean;
 }

package/bin/reciple/classes/CommandCooldownManager.js

@@ -1,15 +1,21 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CommandCooldownManager = void 0;
+/**
+ * Stores cooled-down users
+ */
 class CommandCooldownManager extends Array {
     /**
      * Alias for `CommandCooldownManager#push()`
+     * @param options Cooled-down user data
      */
     add(...options) {
         return this.push(...options);
     }
     /**
      * Remove cooldown from specific user, channel or guild
+     * @param options Remove cooldown data options
+     * @param limit Remove cooldown data limit
      */
     remove(options, limit = 0) {
         if (!Object.keys(options).length)
@@ -28,6 +34,7 @@ class CommandCooldownManager extends Array {
     }
     /**
      * Check if the given user is cooled-down
+     * @param options Options to identify if user is on cooldown
      */
     isCooledDown(options) {
         const data = this.get(options);
@@ -39,7 +46,8 @@ class CommandCooldownManager extends Array {
         return true;
     }
     /**
-     * Clear non cooled-down users from this array
+     * Purge non cooled-down users from this array
+     * @param options Clean cooldown options
      */
     clean(options) {
         for (const index in this) {
@@ -52,12 +60,15 @@ class CommandCooldownManager extends Array {
     }
     /**
      * Get someone's cooldown data
+     * @param options Get cooldown data options
      */
     get(options) {
         return this.find(data => CommandCooldownManager.checkOptions(options, data));
     }
     /**
      * Check if the options are valid
+     * @param options Options to validated
+     * @param data Cooled-down user data
      */
     static checkOptions(options, data) {
         var _a, _b;

package/bin/reciple/classes/MessageCommandOptionManager.d.ts

@@ -1,13 +1,23 @@
 import { MessageCommandValidatedOption } from './builders/MessageCommandBuilder';
+/**
+ * Validated message options manager
+ */
 export declare class MessageCommandOptionManager extends Array<MessageCommandValidatedOption> {
+    /**
+     * @param options Validated options
+     */
     constructor(options: MessageCommandValidatedOption[]);
     /**
      * Get the option info
+     * @param name Option name
+     * @param requied Is the option required
      */
     get(name: string, requied: true): MessageCommandValidatedOption;
     get(name: string, requied?: boolean): MessageCommandValidatedOption | null;
     /**
      * Get the option value
+     * @param name Option name
+     * @param requied Is the option required
      */
     getValue(name: string, requied: true): string;
     getValue(name: string, requied?: boolean): string | null;

package/bin/reciple/classes/MessageCommandOptionManager.js

@@ -1,7 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MessageCommandOptionManager = void 0;
+/**
+ * Validated message options manager
+ */
 class MessageCommandOptionManager extends Array {
+    /**
+     * @param options Validated options
+     */
     constructor(options) {
         super();
         this.push(...options);

package/bin/reciple/classes/RecipleClient.d.ts

@@ -1,16 +1,22 @@
-import { RecipleCommandBuilders, RecipleCommandBuilderType } from '../types/builders';
-import { InteractionCommandBuilder, RecipleInteractionCommandExecuteData } from './builders/InteractionCommandBuilder';
-import { MessageCommandBuilder, RecipleMessageCommandExecuteData } from './builders/MessageCommandBuilder';
-import { InteractionBuilder } from '../registerInteractionCommands';
-import { CommandCooldownManager } from './CommandCooldownManager';
-import { Logger as ILogger } from 'fallout-utility';
-import { AddModuleOptions } from '../types/paramOptions';
 import { RecipleModule } from '../modules';
+import { ApplicationCommandBuilder } from '../registerInteractionCommands';
+import { RecipleCommandBuilder, RecipleCommandBuilderType } from '../types/builders';
+import { RecipleAddModuleOptions } from '../types/paramOptions';
+import { InteractionCommandBuilder, InteractionCommandExecuteData } from './builders/InteractionCommandBuilder';
+import { MessageCommandBuilder, MessageCommandExecuteData } from './builders/MessageCommandBuilder';
+import { CommandCooldownManager } from './CommandCooldownManager';
 import { Config } from './RecipleConfig';
-import { ApplicationCommandData, Awaitable, Client, ClientEvents, ClientOptions, CommandInteraction, Interaction, Message } from 'discord.js';
+import { ApplicationCommandData, Awaitable, ChatInputCommandInteraction, Client, ClientEvents, ClientOptions, Interaction, Message } from 'discord.js';
+import { Logger as ILogger } from 'fallout-utility';
+/**
+ * options for Reciple client
+ */
 export interface RecipleClientOptions extends ClientOptions {
     config?: Config;
 }
+/**
+ * Reciple client commands object interface
+ */
 export interface RecipleClientCommands {
     messageCommands: {
         [commandName: string]: MessageCommandBuilder;
@@ -19,11 +25,17 @@ export interface RecipleClientCommands {
         [commandName: string]: InteractionCommandBuilder;
     };
 }
+/**
+ * Reciple client events
+ */
 export interface RecipleClientEvents extends ClientEvents {
-    recipleMessageCommandCreate: [executeData: RecipleMessageCommandExecuteData];
-    recipleInteractionCommandCreate: [executeData: RecipleInteractionCommandExecuteData];
+    recipleMessageCommandCreate: [executeData: MessageCommandExecuteData];
+    recipleInteractionCommandCreate: [executeData: InteractionCommandExecuteData];
     recipleReplyError: [error: unknown];
 }
+/**
+ * Create new Reciple client
+ */
 export interface RecipleClient<Ready extends boolean = boolean> extends Client<Ready> {
     on<E extends keyof RecipleClientEvents>(event: E, listener: (...args: RecipleClientEvents[E]) => Awaitable<void>): this;
     on<E extends string | symbol>(event: Exclude<E, keyof RecipleClientEvents>, listener: (...args: any) => Awaitable<void>): this;
@@ -40,14 +52,18 @@ export interface RecipleClient<Ready extends boolean = boolean> extends Client<R
 export declare class RecipleClient<Ready extends boolean = boolean> extends Client<Ready> {
     config: Config;
     commands: RecipleClientCommands;
-    otherApplicationCommandData: (InteractionBuilder | ApplicationCommandData)[];
+    otherApplicationCommandData: (ApplicationCommandBuilder | ApplicationCommandData)[];
     commandCooldowns: CommandCooldownManager;
     modules: RecipleModule[];
     logger: ILogger;
     version: string;
+    /**
+     * @param options Client options
+     */
     constructor(options: RecipleClientOptions);
     /**
      * Load modules from modules folder
+     * @param folder Modules folder
      */
     startModules(folder?: string): Promise<RecipleClient<Ready>>;
     /**
@@ -56,30 +72,39 @@ export declare class RecipleClient<Ready extends boolean = boolean> extends Clie
     loadModules(): Promise<RecipleClient<Ready>>;
     /**
      * Add module
+     * @param options Module options
      */
-    addModule(options: AddModuleOptions): Promise<void>;
+    addModule(options: RecipleAddModuleOptions): Promise<void>;
     /**
      * Add interaction or message command to client
+     * @param command Interaction/Message command builder
      */
-    addCommand(command: RecipleCommandBuilders): RecipleClient<Ready>;
+    addCommand(command: RecipleCommandBuilder): RecipleClient<Ready>;
     /**
      * Listed to command executions
      */
     addCommandListeners(): RecipleClient<Ready>;
     /**
      * Execute a Message command
+     * @param message Message command executor
+     * @param prefix Message command prefix
      */
-    messageCommandExecute(message: Message, prefix?: string): Promise<void | RecipleMessageCommandExecuteData>;
+    messageCommandExecute(message: Message, prefix?: string): Promise<void | MessageCommandExecuteData>;
     /**
      * Execute an Interaction command
+     * @param interaction Command Interaction
      */
-    interactionCommandExecute(interaction: Interaction | CommandInteraction): Promise<void | RecipleInteractionCommandExecuteData>;
+    interactionCommandExecute(interaction: Interaction | ChatInputCommandInteraction): Promise<void | InteractionCommandExecuteData>;
     /**
      * Get a message from config
+     * @param messageKey Config messages key
+     * @param defaultMessage Default message when the key does not exists
      */
     getMessage<T = unknown>(messageKey: string, defaultMessage?: T): T;
     /**
      * Get command builder by name or alias if it's a message command
+     * @param command Command name
+     * @param type Command type
      */
     findCommand(command: string, type: RecipleCommandBuilderType.MessageCommand): MessageCommandBuilder | undefined;
     findCommand(command: string, type: RecipleCommandBuilderType.InteractionCommand): InteractionCommandBuilder | undefined;
@@ -89,10 +114,19 @@ export declare class RecipleClient<Ready extends boolean = boolean> extends Clie
     isClientLogsEnabled(): boolean;
     /**
      * Emits the "recipleReplyError" event
+     * @param error Received Error
      */
     private _replyError;
+    /**
+     * Executes command halt function
+     * @param command Halted command's builder
+     * @param haltData Halted command's data
+     */
+    private _haltCommand;
     /**
      * Error message when a command fails to execute
+     * @param err Received error
+     * @param command Interaction/Message command execute data
      */
     private _commandExecuteError;
 }

package/bin/reciple/classes/RecipleClient.js

@@ -1,5 +1,4 @@
 "use strict";
-// Not cool code
 var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
     function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
     return new (P || (P = Promise))(function (resolve, reject) {
@@ -11,19 +10,24 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RecipleClient = void 0;
-const builders_1 = require("../types/builders");
+// Not cool code
+const logger_1 = require("../logger");
+const modules_1 = require("../modules");
 const permissions_1 = require("../permissions");
 const registerInteractionCommands_1 = require("../registerInteractionCommands");
+const builders_1 = require("../types/builders");
+const commands_1 = require("../types/commands");
+const version_1 = require("../version");
+const MessageCommandBuilder_1 = require("./builders/MessageCommandBuilder");
 const CommandCooldownManager_1 = require("./CommandCooldownManager");
 const MessageCommandOptionManager_1 = require("./MessageCommandOptionManager");
-const fallout_utility_1 = require("fallout-utility");
-const commands_1 = require("../types/commands");
-const modules_1 = require("../modules");
 const RecipleConfig_1 = require("./RecipleConfig");
-const version_1 = require("../version");
-const logger_1 = require("../logger");
 const discord_js_1 = require("discord.js");
+const fallout_utility_1 = require("fallout-utility");
 class RecipleClient extends discord_js_1.Client {
+    /**
+     * @param options Client options
+     */
     constructor(options) {
         var _a, _b, _c;
         super(options);
@@ -33,7 +37,7 @@ class RecipleClient extends discord_js_1.Client {
         this.commandCooldowns = new CommandCooldownManager_1.CommandCooldownManager();
         this.modules = [];
         this.version = version_1.version;
-        this.logger = (0, logger_1.logger)(!!((_a = options.config) === null || _a === void 0 ? void 0 : _a.fileLogging.stringifyLoggedJSON), !!((_b = options.config) === null || _b === void 0 ? void 0 : _b.fileLogging.debugmode));
+        this.logger = (0, logger_1.createLogger)(!!((_a = options.config) === null || _a === void 0 ? void 0 : _a.fileLogging.stringifyLoggedJSON), !!((_b = options.config) === null || _b === void 0 ? void 0 : _b.fileLogging.debugmode));
         if (!options.config)
             throw new Error('Config is not defined.');
         this.config = Object.assign(Object.assign({}, this.config), ((_c = options.config) !== null && _c !== void 0 ? _c : {}));
@@ -42,6 +46,7 @@ class RecipleClient extends discord_js_1.Client {
     }
     /**
      * Load modules from modules folder
+     * @param folder Modules folder
      */
     startModules(folder) {
         return __awaiter(this, void 0, void 0, function* () {
@@ -95,6 +100,7 @@ class RecipleClient extends discord_js_1.Client {
     }
     /**
      * Add module
+     * @param options Module options
      */
     addModule(options) {
         var _a;
@@ -125,6 +131,7 @@ class RecipleClient extends discord_js_1.Client {
     }
     /**
      * Add interaction or message command to client
+     * @param command Interaction/Message command builder
      */
     addCommand(command) {
         var _a;
@@ -151,6 +158,8 @@ class RecipleClient extends discord_js_1.Client {
     }
     /**
      * Execute a Message command
+     * @param message Message command executor
+     * @param prefix Message command prefix
      */
     messageCommandExecute(message, prefix) {
         var _a;
@@ -163,15 +172,19 @@ class RecipleClient extends discord_js_1.Client {
             const command = this.findCommand(parseCommand.command, builders_1.RecipleCommandBuilderType.MessageCommand);
             if (!command)
                 return;
-            const commandOptions = command.getCommandOptionValues(parseCommand);
+            const commandOptions = (0, MessageCommandBuilder_1.validateMessageCommandOptions)(command, parseCommand);
             const executeData = {
                 message: message,
-                options: new MessageCommandOptionManager_1.MessageCommandOptionManager(commandOptions),
+                options: commandOptions,
                 command: parseCommand,
                 builder: command,
                 client: this
             };
-            if ((0, permissions_1.userHasCommandPermissions)(command.name, (_a = message.member) === null || _a === void 0 ? void 0 : _a.permissions, this.config.commands.messageCommand.permissions, command)) {
+            if ((0, permissions_1.userHasCommandPermissions)({
+                builder: command,
+                memberPermissions: (_a = message.member) === null || _a === void 0 ? void 0 : _a.permissions,
+                commandPermissions: this.config.commands.messageCommand.permissions
+            })) {
                 if (!command.allowExecuteInDM && message.channel.type === discord_js_1.ChannelType.DM
                     || !command.allowExecuteByBots
                         && (message.author.bot || message.author.system)
@@ -185,14 +198,14 @@ class RecipleClient extends discord_js_1.Client {
                         return;
                     }
                     if (commandOptions.some(o => o.missing)) {
-                        if (!command.halt || !(yield command.halt({ executeData, reason: commands_1.RecipleHaltedCommandReason.MissingArguments, missingArguments: new MessageCommandOptionManager_1.MessageCommandOptionManager(executeData.options.filter(o => o.missing)) }))) {
+                        if (!(yield this._haltCommand(command, { executeData, reason: commands_1.RecipleHaltedCommandReason.MissingArguments, missingArguments: new MessageCommandOptionManager_1.MessageCommandOptionManager(executeData.options.filter(o => o.missing)) }))) {
                             message.reply(this.getMessage('missingArguments', 'Not enough arguments.')).catch(er => this._replyError(er));
                         }
                         return;
                     }
                 }
                 if (message.guild && !(0, permissions_1.botHasExecutePermissions)(message.guild, command.requiredBotPermissions)) {
-                    if (!command.halt || !(yield command.halt({ executeData, reason: commands_1.RecipleHaltedCommandReason.MissingBotPermissions }))) {
+                    if (!(yield this._haltCommand(command, { executeData, reason: commands_1.RecipleHaltedCommandReason.MissingBotPermissions }))) {
                         message.reply(this.getMessage('insufficientBotPerms', 'Insufficient bot permissions.')).catch(er => this._replyError(er));
                     }
                     return;
@@ -208,7 +221,7 @@ class RecipleClient extends discord_js_1.Client {
                     this.commandCooldowns.add(Object.assign(Object.assign({}, userCooldown), { expireTime: Date.now() + command.cooldown }));
                 }
                 else if (this.config.commands.messageCommand.enableCooldown && command.cooldown) {
-                    if (!command.halt || !(yield command.halt(Object.assign({ executeData, reason: commands_1.RecipleHaltedCommandReason.Cooldown }, this.commandCooldowns.get(userCooldown))))) {
+                    if (!(yield this._haltCommand(command, Object.assign({ executeData, reason: commands_1.RecipleHaltedCommandReason.Cooldown }, this.commandCooldowns.get(userCooldown))))) {
                         yield message.reply(this.getMessage('cooldown', 'You cannot execute this command right now due to the cooldown.')).catch(er => this._replyError(er));
                     }
                     return;
@@ -216,27 +229,28 @@ class RecipleClient extends discord_js_1.Client {
                 try {
                     yield Promise.resolve(command.execute(executeData))
                         .then(() => this.emit('recipleMessageCommandCreate', executeData))
-                        .catch((err) => __awaiter(this, void 0, void 0, function* () { return !command.halt || !(yield command.halt({ executeData, reason: commands_1.RecipleHaltedCommandReason.Error, error: err })) ? this._commandExecuteError(err, executeData) : void 0; }));
+                        .catch((err) => __awaiter(this, void 0, void 0, function* () { return (yield this._haltCommand(command, { executeData, reason: commands_1.RecipleHaltedCommandReason.Error, error: err })) ? this._commandExecuteError(err, executeData) : void 0; }));
                     return executeData;
                 }
                 catch (err) {
-                    if (!command.halt || !(yield command.halt({ executeData, reason: commands_1.RecipleHaltedCommandReason.Error, error: err }))) {
+                    if (!(yield this._haltCommand(command, { executeData, reason: commands_1.RecipleHaltedCommandReason.Error, error: err }))) {
                         this._commandExecuteError(err, executeData);
                     }
                 }
             }
-            else if (!command.halt || !(yield command.halt({ executeData, reason: commands_1.RecipleHaltedCommandReason.MissingMemberPermissions }))) {
+            else if (!(yield this._haltCommand(command, { executeData, reason: commands_1.RecipleHaltedCommandReason.MissingMemberPermissions }))) {
                 message.reply(this.getMessage('noPermissions', 'You do not have permission to use this command.')).catch(er => this._replyError(er));
             }
         });
     }
     /**
      * Execute an Interaction command
+     * @param interaction Command Interaction
      */
     interactionCommandExecute(interaction) {
         var _a, _b;
         return __awaiter(this, void 0, void 0, function* () {
-            if (!interaction || interaction.type !== discord_js_1.InteractionType.ApplicationCommand || !this.isReady())
+            if (!interaction || interaction.type !== discord_js_1.InteractionType.ApplicationCommand || !interaction.isChatInputCommand() || !this.isReady())
                 return;
             const command = this.findCommand(interaction.commandName, builders_1.RecipleCommandBuilderType.InteractionCommand);
             if (!command)
@@ -246,11 +260,15 @@ class RecipleClient extends discord_js_1.Client {
                 builder: command,
                 client: this
             };
-            if ((0, permissions_1.userHasCommandPermissions)(command.name, (_a = interaction.memberPermissions) !== null && _a !== void 0 ? _a : undefined, this.config.commands.interactionCommand.permissions, command)) {
+            if ((0, permissions_1.userHasCommandPermissions)({
+                builder: command,
+                memberPermissions: (_a = interaction.memberPermissions) !== null && _a !== void 0 ? _a : undefined,
+                commandPermissions: this.config.commands.interactionCommand.permissions
+            })) {
                 if (!command || (0, permissions_1.isIgnoredChannel)(interaction.channelId, this.config.ignoredChannels))
                     return;
                 if (interaction.guild && !(0, permissions_1.botHasExecutePermissions)(interaction.guild, command.requiredBotPermissions)) {
-                    if (!command.halt || !(yield command.halt({ executeData, reason: commands_1.RecipleHaltedCommandReason.MissingBotPermissions }))) {
+                    if (!(yield this._haltCommand(command, { executeData, reason: commands_1.RecipleHaltedCommandReason.MissingBotPermissions }))) {
                         yield interaction.reply(this.getMessage('insufficientBotPerms', 'Insufficient bot permissions.')).catch(er => this._replyError(er));
                     }
                     return;
@@ -266,7 +284,7 @@ class RecipleClient extends discord_js_1.Client {
                     this.commandCooldowns.add(Object.assign(Object.assign({}, userCooldown), { expireTime: Date.now() + command.cooldown }));
                 }
                 else if (this.config.commands.interactionCommand.enableCooldown && command.cooldown) {
-                    if (!command.halt || !(yield command.halt(Object.assign({ executeData, reason: commands_1.RecipleHaltedCommandReason.Cooldown }, this.commandCooldowns.get(userCooldown))))) {
+                    if (!(yield this._haltCommand(command, Object.assign({ executeData, reason: commands_1.RecipleHaltedCommandReason.Cooldown }, this.commandCooldowns.get(userCooldown))))) {
                         yield interaction.reply(this.getMessage('cooldown', 'You cannot execute this command right now due to the cooldown.')).catch(er => this._replyError(er));
                     }
                     return;
@@ -274,22 +292,24 @@ class RecipleClient extends discord_js_1.Client {
                 try {
                     yield Promise.resolve(command.execute(executeData))
                         .then(() => this.emit('recipleInteractionCommandCreate', executeData))
-                        .catch((err) => __awaiter(this, void 0, void 0, function* () { return !command.halt || !(yield command.halt({ executeData, reason: commands_1.RecipleHaltedCommandReason.Error, error: err })) ? this._commandExecuteError(err, executeData) : void 0; }));
+                        .catch((err) => __awaiter(this, void 0, void 0, function* () { return (yield this._haltCommand(command, { executeData, reason: commands_1.RecipleHaltedCommandReason.Error, error: err })) ? this._commandExecuteError(err, executeData) : void 0; }));
                     return executeData;
                 }
                 catch (err) {
-                    if (!command.halt || !(yield command.halt({ executeData, reason: commands_1.RecipleHaltedCommandReason.Error, error: err }))) {
+                    if (!(yield this._haltCommand(command, { executeData, reason: commands_1.RecipleHaltedCommandReason.Error, error: err }))) {
                         this._commandExecuteError(err, executeData);
                     }
                 }
             }
-            else if (!command.halt || !(yield command.halt({ executeData, reason: commands_1.RecipleHaltedCommandReason.MissingMemberPermissions }))) {
+            else if (!(yield this._haltCommand(command, { executeData, reason: commands_1.RecipleHaltedCommandReason.MissingMemberPermissions }))) {
                 yield interaction.reply(this.getMessage('noPermissions', 'You do not have permission to use this command.')).catch(er => this._replyError(er));
             }
         });
     }
     /**
      * Get a message from config
+     * @param messageKey Config messages key
+     * @param defaultMessage Default message when the key does not exists
      */
     getMessage(messageKey, defaultMessage) {
         var _a, _b;
@@ -316,12 +336,34 @@ class RecipleClient extends discord_js_1.Client {
     }
     /**
      * Emits the "recipleReplyError" event
+     * @param error Received Error
      */
     _replyError(error) {
         this.emit('recipleReplyError', error);
     }
+    _haltCommand(command, haltData) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                return (_a = (command.halt
+                    ? yield (command.builder == builders_1.RecipleCommandBuilderType.InteractionCommand
+                        ? Promise.resolve(command.halt(haltData))
+                        : Promise.resolve(command.halt(haltData))).catch(() => false)
+                    : false)) !== null && _a !== void 0 ? _a : false;
+            }
+            catch (err) {
+                if (this.isClientLogsEnabled()) {
+                    this.logger.error(`Halt command "${command.name}" execute error`);
+                    this.logger.error(err);
+                }
+                return false;
+            }
+        });
+    }
     /**
      * Error message when a command fails to execute
+     * @param err Received error
+     * @param command Interaction/Message command execute data
      */
     _commandExecuteError(err, command) {
         return __awaiter(this, void 0, void 0, function* () {