discordthing 0.1.2 → 0.2.0

package/build/bot.d.ts

@@ -1,7 +1,8 @@
-import { type ReturnResult } from "@l3dev/result";
-import { Client, REST, SlashCommandBuilder, type ClientOptions, type Guild, type RestOrArray } from "discord.js";
-import type { Command, CommandFilter } from "./commands/command.js";
+import { Client, REST, SlashCommandBuilder, type ClientOptions } from "discord.js";
+import type { Command } from "./commands/command.js";
+import { CommandManager } from "./commands/manager.js";
 import type { Listener } from "./events/listener.js";
+import { EventsManager } from "./events/manager.js";
 import type { ILogger } from "./logger.js";
 import type { Plugin } from "./plugin.js";
 export type BotOptions = {
@@ -15,23 +16,18 @@ export declare class Bot {
     readonly client: Client<boolean>;
     private _rest;
     get rest(): REST;
+    readonly logger: ILogger;
+    readonly commands: CommandManager;
+    readonly events: EventsManager;
     private readonly plugins;
-    private readonly commands;
-    private readonly commandFilters;
-    private readonly readyListeners;
-    private readonly logger;
     constructor(options: BotOptions, clientOptions: ClientOptions);
-    addCommands(...commands: RestOrArray<Command<string, SlashCommandBuilder>>): void;
-    addCommand(command: Command<string, SlashCommandBuilder>): void;
-    addCommandFilter(filter: CommandFilter): void;
-    addListeners(...listeners: RestOrArray<Listener<any>>): void;
-    addListener(listener: Listener<any>): void;
-    private createListenerFn;
-    start(token: string): Promise<void>;
-    getMe(guild: Guild): Promise<ReturnResult<import("discord.js").GuildMember, import("@l3dev/result").ResultErrorDefinition<"GET_ME", object & {
-        error: Error;
-    }>>>;
-    private registerCommands;
+    /**
+     * Starts the bot and establishes a WebSocket connection to Discord.
+     * @param token Token of the account to log in with
+     * @returns Token of the account used
+     * @example
+     * bot.start('my token');
+     */
+    start(token: string): Promise<string>;
     private onReady;
-    private onInteraction;
 }

package/build/bot.js

@@ -1,19 +1,17 @@
-import { err, ok, Result } from "@l3dev/result";
-import { Client, Events, InteractionContextType, REST, SlashCommandBuilder } from "discord.js";
+import { Client, Events, REST, SlashCommandBuilder } from "discord.js";
 import { Logger } from "tslog";
-import { CommandRegistration } from "./commands/registration.js";
-import { createContext } from "./context.js";
+import { CommandManager } from "./commands/manager.js";
+import { EventsManager } from "./events/manager.js";
 export class Bot {
     client;
     _rest;
     get rest() {
         return this._rest;
     }
-    plugins;
-    commands;
-    commandFilters = [];
-    readyListeners = [];
     logger;
+    commands;
+    events;
+    plugins;
     constructor(options, clientOptions) {
         this._rest = new REST({ version: "10" });
         this.client = new Client(clientOptions);
@@ -26,146 +24,37 @@ export class Bot {
         for (const plugin of this.plugins) {
             plugin.resolved(this);
         }
-        this.commands = [
-            ...(options.commands ?? []),
-            ...this.plugins.flatMap((plugin) => plugin.commands)
-        ].reduce((acc, command) => ({
-            ...acc,
-            [command.name]: command
-        }), {});
+        this.commands = new CommandManager(this, {
+            commands: [...(options.commands ?? []), ...this.plugins.flatMap((plugin) => plugin.commands)]
+        });
+        this.events = new EventsManager(this, {
+            listeners: [
+                ...(options.listeners ?? []),
+                ...this.plugins.flatMap((plugin) => plugin.listeners)
+            ]
+        });
+        this.client.on(Events.Debug, (message) => {
+            this.logger.debug(message);
+        });
         this.client.on(Events.ClientReady, this.onReady.bind(this));
-        this.client.on(Events.InteractionCreate, this.onInteraction.bind(this));
-        const allListeners = [
-            ...(options.listeners ?? []),
-            ...this.plugins.flatMap((plugin) => plugin.listeners)
-        ];
-        for (const listener of allListeners) {
-            if (listener.event === Events.ClientReady) {
-                this.readyListeners.push(listener);
-                continue;
-            }
-            this.client.on(listener.event, this.createListenerFn(listener));
-        }
-    }
-    addCommands(...commands) {
-        for (const command of commands.flat()) {
-            this.addCommand(command);
-        }
-    }
-    addCommand(command) {
-        if (this.client.isReady()) {
-            throw new Error("Cannot add command after bot has started");
-        }
-        this.commands[command.name] = command;
-    }
-    addCommandFilter(filter) {
-        this.commandFilters.push(filter);
-    }
-    addListeners(...listeners) {
-        for (const listener of listeners.flat()) {
-            this.addListener(listener);
-        }
-    }
-    addListener(listener) {
-        if (this.client.isReady()) {
-            throw new Error("Cannot add listener after bot has started");
-        }
-        if (listener.event === Events.ClientReady) {
-            this.readyListeners.push(listener);
-            return;
-        }
-        (listener.once ? this.client.once : this.client.on)(listener.event, this.createListenerFn(listener));
-    }
-    createListenerFn(listener) {
-        return async (...args) => {
-            const ctx = createContext(this, this.logger);
-            try {
-                await listener.handler(ctx, ...args);
-            }
-            catch (error) {
-                this.logger.error(`Error in listener ${listener.event}:`, error);
-            }
-        };
     }
+    /**
+     * Starts the bot and establishes a WebSocket connection to Discord.
+     * @param token Token of the account to log in with
+     * @returns Token of the account used
+     * @example
+     * bot.start('my token');
+     */
     async start(token) {
         this._rest = this._rest.setToken(token);
-        await this.client.login(token);
-    }
-    async getMe(guild) {
-        if (guild.members.me) {
-            return ok(guild.members.me);
-        }
-        return await Result.fromPromise(guild.members.fetchMe(), {
-            onError: { type: "GET_ME" }
-        });
-    }
-    async registerCommands(client) {
-        const commandRegistration = new CommandRegistration(this._rest, client);
-        const globalCommands = Object.values(this.commands).filter((command) => {
-            const contexts = command.getContexts();
-            return (contexts.includes(InteractionContextType.BotDM) ||
-                contexts.includes(InteractionContextType.PrivateChannel));
-        });
-        const guildCommands = Object.values(this.commands).filter((command) => {
-            const contexts = command.getContexts();
-            return contexts.includes(InteractionContextType.Guild);
-        });
-        this.logger.debug(`Registering global commands...`);
-        await commandRegistration.registerGlobalCommands(globalCommands);
-        const guilds = await client.guilds.fetch();
-        for (const guild of guilds.values()) {
-            this.logger.debug(`Registering guild commands for guild ${guild.id}...`);
-            await commandRegistration.registerGuildCommands(guild.id, guildCommands);
-        }
+        return await this.client.login(token);
     }
     async onReady(client) {
         const startMs = performance.now();
-        await this.registerCommands(client);
-        // Make a copy so we can remove _once_ listeners
-        const listeners = [...this.readyListeners];
-        for (const listener of listeners) {
-            const handler = this.createListenerFn(listener);
-            handler(client);
-            if (listener.once) {
-                const index = this.readyListeners.indexOf(listener);
-                if (index === -1) {
-                    return;
-                }
-                this.readyListeners.splice(index, 1);
-            }
-        }
+        await this.commands.register(client);
+        await this.events.runReadyListeners(client);
         const endMs = performance.now();
         const elapsedMs = endMs - startMs;
         this.logger.info(`Ready! (${elapsedMs > 1000 ? `${(elapsedMs / 1000).toFixed(2)}s` : `${elapsedMs}ms`})`);
     }
-    async onInteraction(interaction) {
-        if (interaction.user.bot || !interaction.isChatInputCommand())
-            return;
-        const command = this.commands[interaction.commandName];
-        if (!command) {
-            this.logger.error(`Unknown command '${interaction.commandName}'`);
-            return;
-        }
-        if (!this.commandFilters.some((filter) => filter(interaction, command))) {
-            return;
-        }
-        const ctx = createContext(this, this.logger);
-        ctx.interaction = interaction;
-        let result;
-        try {
-            result = await command.execute(ctx);
-        }
-        catch (error) {
-            result = err("COMMAND_FAILED", {
-                command: interaction.commandName,
-                interactionId: interaction.id,
-                error
-            });
-        }
-        const unwrapped = Result.unwrap(result);
-        if (!unwrapped.ok) {
-            this.logger.error(`Error while executing command '${interaction.commandName}':`, result);
-        }
-    }
 }
-//# sourceMappingURL=bot.js.map

package/build/commands/command.d.ts

@@ -1,11 +1,9 @@
-import { type ReturnResult } from "@l3dev/result";
-import { InteractionContextType, SlashCommandBuilder, SlashCommandSubcommandBuilder, type ChatInputCommandInteraction, type SharedNameAndDescription, type SharedSlashCommandOptions } from "discord.js";
-import type { GenericCtx } from "../context.js";
+import { type Err, type ReturnResult } from "@l3dev/result";
+import { InteractionContextType, SlashCommandBuilder, SlashCommandSubcommandBuilder, type ChatInputCommandInteraction, type CommandInteractionOption, type SharedNameAndDescription, type SharedSlashCommandOptions } from "discord.js";
+import type * as z from "zod";
 import type { Args, OptionDefinitions } from "../options/index.js";
-import type { Expand, MaybePromise } from "../utility-types.js";
-export type CommandCtx = Expand<GenericCtx & {
-    interaction: ChatInputCommandInteraction;
-}>;
+import type { MaybePromise } from "../utility-types.js";
+import type { CommandCtx } from "./context.js";
 export type ArgsArrayForOptions<Options extends OptionDefinitions> = [Options] extends [
     OptionDefinitions
 ] ? [args: Args<Options>] : [];
@@ -109,3 +107,24 @@ export declare function subcommand<Name extends string, Options extends OptionDe
     handler: (ctx: CommandCtx, ...args: ArgsArrayForOptions<Options>) => MaybePromise<ReturnResult<any, any>>;
 }): Command<Name, SlashCommandSubcommandBuilder>;
 export type CommandFilter = (interaction: ChatInputCommandInteraction, command: Command<string, SlashCommandBuilder>) => boolean;
+type KnownCommandError = Err<"OPTION_ERROR", {
+    error: Error;
+}> | Err<"INVALID_OPTION_TYPE", {
+    name: string;
+    option: CommandInteractionOption;
+}> | Err<"MISSING_OPTION", {
+    name: string;
+}> | Err<"INVALID_OPTION_VALUE", {
+    zodError: z.ZodError;
+    name: string;
+    value: any;
+}> | Err<"UNKNOWN_COMMAND", {
+    command: string;
+}> | Err<"UNKNOWN_SUBCOMMAND", {
+    subcommand: string;
+}> | Err<"COMMAND_FAILED", {
+    command: string;
+    error: Error;
+}>;
+export type ErrorHandler = (ctx: CommandCtx, error: KnownCommandError | Err<string & {}, any>) => void | Promise<void>;
+export {};

package/build/commands/command.js

@@ -1,6 +1,6 @@
-import { err, NONE } from "@l3dev/result";
-import { ApplicationCommandOptionType, InteractionContextType, SlashCommandBuilder, SlashCommandSubcommandBuilder } from "discord.js";
-import { AttachmentOption, BooleanOption, BuilderOption, ChannelOption, IntegerOption, MentionableOption, NumberOption, RoleOption, StringOption, UserOption } from "../options/options.js";
+import { err, NONE, ok, Result } from "@l3dev/result";
+import { ApplicationCommandOptionType, DiscordjsErrorCodes, DiscordjsTypeError, InteractionContextType, SlashCommandBuilder, SlashCommandSubcommandBuilder } from "discord.js";
+import { AttachmentOption, BooleanOption, ChannelOption, IntegerOption, MentionableOption, NumberOption, RoleOption, StringOption, UserOption } from "../options/options.js";
 export class Command {
     builder;
     name;
@@ -34,12 +34,16 @@ export class Command {
             const subcommand = this.subcommands[subcommandName];
             if (!subcommand) {
                 return err("UNKNOWN_SUBCOMMAND", {
-                    name: subcommandName
+                    subcommand: subcommandName
                 });
             }
             return await subcommand.execute(ctx);
         }
-        const args = this.parseOptions(ctx.interaction.options);
+        const parseResult = this.parseOptions(ctx.interaction.options);
+        if (!parseResult.ok) {
+            return parseResult;
+        }
+        const args = parseResult.value;
         return await this.handler(ctx, args);
     }
     /** @internal */
@@ -47,40 +51,73 @@ export class Command {
         const args = {};
         for (const [name, option] of Object.entries(this.options ?? {})) {
             const required = option.isOptional === "required";
-            let value = null;
-            if (options.getAttachment && option instanceof AttachmentOption) {
-                value = options.getAttachment(name, required);
-            }
-            else if (options.getBoolean && option instanceof BooleanOption) {
-                value = options.getBoolean(name, required);
-            }
-            else if (options.getChannel && option instanceof ChannelOption) {
-                value = options.getChannel(name, required, option.getBuilder().channel_types);
-            }
-            else if (options.getInteger && option instanceof IntegerOption) {
-                value = options.getInteger(name, required);
-            }
-            else if (options.getMentionable && option instanceof MentionableOption) {
-                value = options.getMentionable(name, required);
-            }
-            else if (options.getNumber && option instanceof NumberOption) {
-                value = options.getNumber(name, required);
-            }
-            else if (options.getRole && option instanceof RoleOption) {
-                value = options.getRole(name, required);
-            }
-            else if (options.getString && option instanceof StringOption) {
-                value = options.getString(name, required);
-            }
-            else if (options.getUser && option instanceof UserOption) {
-                value = options.getUser(name, required);
+            const result = Result.from(() => {
+                if (option instanceof AttachmentOption) {
+                    return options.getAttachment(name, required);
+                }
+                else if (option instanceof BooleanOption) {
+                    return options.getBoolean(name, required);
+                }
+                else if (option instanceof ChannelOption) {
+                    return options.getChannel(name, required, option.getBuilder().channel_types);
+                }
+                else if (option instanceof IntegerOption) {
+                    return options.getInteger(name, required);
+                }
+                else if (option instanceof MentionableOption) {
+                    return options.getMentionable(name, required);
+                }
+                else if (option instanceof NumberOption) {
+                    return options.getNumber(name, required);
+                }
+                else if (option instanceof RoleOption) {
+                    return options.getRole(name, required);
+                }
+                else if (option instanceof StringOption) {
+                    return options.getString(name, required);
+                }
+                else if (option instanceof UserOption) {
+                    return options.getUser(name, required);
+                }
+                return null;
+            }, {
+                onError: { type: "OPTION_ERROR" }
+            });
+            if (!result.ok) {
+                const error = result.context.error;
+                if (error instanceof DiscordjsTypeError) {
+                    switch (error.code) {
+                        case DiscordjsErrorCodes.CommandInteractionOptionType:
+                            return err("INVALID_OPTION_TYPE", {
+                                name,
+                                option: options.get(name)
+                            });
+                        case DiscordjsErrorCodes.CommandInteractionOptionEmpty:
+                            return err("MISSING_OPTION", {
+                                name
+                            });
+                    }
+                }
+                return result;
             }
+            let value = result.value;
             if (value === null || value === undefined) {
                 continue;
             }
+            if (option.validator) {
+                const validatorResult = option.validator.safeParse(value);
+                if (!validatorResult.success) {
+                    return err("INVALID_OPTION_VALUE", {
+                        zodError: validatorResult.error,
+                        name,
+                        value
+                    });
+                }
+                value = validatorResult.data;
+            }
             args[name] = value;
         }
-        return args;
+        return ok(args);
     }
     /** @internal */
     getContexts() {
@@ -97,9 +134,7 @@ export class Command {
     setOptions(options) {
         this.options = options;
         for (const [name, option] of Object.entries(options)) {
-            if (option instanceof BuilderOption) {
-                this.addOption(name, option);
-            }
+            this.addOption(name, option);
         }
     }
     /** @internal */
@@ -173,4 +208,3 @@ export function subcommand(command) {
     subcommand.setHandler(command.handler);
     return subcommand;
 }
-//# sourceMappingURL=command.js.map

package/build/commands/context.d.ts

@@ -0,0 +1,23 @@
+import { type Err, type Ok } from "@l3dev/result";
+import type { ChatInputCommandInteraction, InteractionEditReplyOptions, InteractionReplyOptions, Message, MessagePayload, MessageResolvable } from "discord.js";
+import type { Bot } from "../bot.js";
+import { type GenericCtx } from "../context.js";
+import type { Expand } from "../utility-types.js";
+type ReplyPosition = number | "@original" | "@last";
+export type CommandCtx = Expand<GenericCtx & {
+    interaction: ChatInputCommandInteraction;
+    replies: readonly Message[];
+    reply(options: string | MessagePayload | InteractionReplyOptions): Promise<Ok<Message> | Err<"COMMAND_REPLY", {
+        error: Error;
+    }>>;
+    editReply(options: string | MessagePayload | InteractionEditReplyOptions): Promise<Ok<Message> | Err<"COMMAND_NOT_REPLIED", null> | Err<"COMMAND_EDIT_REPLY", {
+        error: Error;
+    }>>;
+    deleteReply(message: MessageResolvable | ReplyPosition): Promise<Ok<void> | Err<"COMMAND_NOT_REPLIED", null> | Err<"COMMAND_REPLY_NOT_FOUND", {
+        message: MessageResolvable | ReplyPosition;
+    }> | Err<"COMMAND_DELETE_REPLY", {
+        error: Error;
+    }>>;
+}>;
+export declare function createCommandContext(bot: Bot, interaction: ChatInputCommandInteraction): CommandCtx;
+export {};

package/build/commands/context.js

@@ -0,0 +1,75 @@
+import { err, Result } from "@l3dev/result";
+import { createGenericContext } from "../context.js";
+export function createCommandContext(bot, interaction) {
+    const replies = [];
+    return {
+        ...createGenericContext(bot),
+        interaction,
+        replies: replies,
+        async reply(options) {
+            let promise;
+            if (interaction.replied || interaction.deferred) {
+                promise = interaction.followUp(options);
+            }
+            else {
+                promise = interaction.reply(options).then((response) => response.fetch());
+            }
+            const result = await Result.fromPromise(promise, {
+                onError: { type: "COMMAND_REPLY" }
+            });
+            if (!result.ok) {
+                return result;
+            }
+            replies.push(result.value);
+            return result;
+        },
+        async editReply(options) {
+            if (!interaction.deferred && !interaction.replied) {
+                return err("COMMAND_NOT_REPLIED");
+            }
+            return await Result.fromPromise(interaction.editReply(options), {
+                onError: { type: "COMMAND_EDIT_REPLY" }
+            });
+        },
+        async deleteReply(message = "@original") {
+            if (!interaction.deferred && !interaction.replied) {
+                return err("COMMAND_NOT_REPLIED");
+            }
+            let position = -1;
+            if (typeof message === "number") {
+                const reply = replies[message];
+                if (reply) {
+                    position = message;
+                    message = reply;
+                }
+            }
+            else if (message === "@last") {
+                const lastPosition = replies.length - 1;
+                const reply = replies[lastPosition];
+                if (reply) {
+                    position = lastPosition;
+                    message = reply;
+                }
+            }
+            else if (message === "@original") {
+                position = 0;
+            }
+            else {
+                const resolvable = message;
+                position = replies.findIndex((reply) => reply.id === (typeof resolvable === "string" ? resolvable : resolvable.id));
+            }
+            if (position === -1) {
+                return err("COMMAND_REPLY_NOT_FOUND", {
+                    message
+                });
+            }
+            const result = await Result.fromPromise(interaction.deleteReply(message), {
+                onError: { type: "COMMAND_DELETE_REPLY" }
+            });
+            if (result.ok) {
+                replies.splice(position, 1);
+            }
+            return result;
+        }
+    };
+}

package/build/commands/diff.js

@@ -39,4 +39,3 @@ export function diffCheck({ prev, next }) {
     }
     return false;
 }
-//# sourceMappingURL=diff.js.map

package/build/commands/index.d.ts

@@ -1,2 +1,4 @@
 export { command, subcommand } from "./command.js";
-export type { CommandCtx, CommandMeta, SubcommandMeta, Command, CommandFilter } from "./command.js";
+export type { CommandMeta, SubcommandMeta, Command, CommandFilter } from "./command.js";
+export type { CommandCtx } from "./context.js";
+export type { CommandManager, CommandManagerOptions } from "./manager.js";

package/build/commands/index.js

@@ -1,2 +1 @@
 export { command, subcommand } from "./command.js";
-//# sourceMappingURL=index.js.map

package/build/commands/manager.d.ts

@@ -0,0 +1,64 @@
+import { type RestOrArray, type SlashCommandBuilder } from "discord.js";
+import type { Command, CommandFilter, ErrorHandler } from "./command.js";
+import type { Bot } from "../bot.js";
+export type CommandManagerOptions = {
+    commands?: Command<string, SlashCommandBuilder>[];
+};
+export declare class CommandManager {
+    private readonly bot;
+    private readonly commands;
+    private readonly commandFilters;
+    private errorHandler;
+    constructor(bot: Bot, options: CommandManagerOptions);
+    /**
+     * Adds commands to the bot.
+     * @param commands The commands to add
+     * @returns A result indicating whether the commands were added successfully
+     * @example
+     * bot.commands.addMany(myCommand1, myCommand2);
+     * bot.commands.addMany([myCommand1, myCommand2]);
+     */
+    addMany(...commands: RestOrArray<Command<string, SlashCommandBuilder>>): import("@l3dev/result").Err<"BOT_ALREADY_STARTED", {
+        message: string;
+    }> | import("@l3dev/result").Ok<void[]>;
+    /**
+     * Adds a command to the bot.
+     * @param command The command to add
+     * @returns A result indicating whether the command was added successfully
+     * @example
+     * const myCommand = command({
+     * 	meta: {
+     * 		name: 'my-command',
+     * 	},
+     * 	handler: async (ctx) => {
+     * 		// your code here
+     * 	}
+     * });
+     *
+     * bot.commands.add(myCommand);
+     */
+    add(command: Command<string, SlashCommandBuilder>): import("@l3dev/result").None | import("@l3dev/result").Err<"BOT_ALREADY_STARTED", {
+        message: string;
+    }>;
+    /**
+     * Adds a command filter that determines whether a command should be executed.
+     * @param filter The filter to add to the bot
+     * @example
+     * bot.commands.addFilter(async (interaction, command) => {
+     * 	if (interaction.guild.id !== process.env.GUILD_ID) return false;
+     * 	return true;
+     * });
+     */
+    addFilter(filter: CommandFilter): void;
+    /**
+     * Sets the command error handler for the bot.
+     * @param handler The error handler to use
+     * @example
+     * bot.commands.setErrorHandler(async (ctx, err) => {
+     * 	await ctx.interaction.reply("An error occurred!");
+     * });
+     */
+    setErrorHandler(handler: ErrorHandler): void;
+    private onInteraction;
+    private executeCommand;
+}