feat: new command handler

Author: twlite

packages/commandkit/src/CommandKit.ts

@@ -13,6 +13,7 @@ import { AppCommandHandler } from './app/handlers/AppCommandHandler';
 import { LocalizationStrategy } from './app/i18n/LocalizationStrategy';
 import { CommandsRouter, EventsRouter } from './app/router';
 import { AppEventsHandler } from './app/handlers/AppEventsHandler';
+import { CommandKitPluginRuntime } from './plugins/runtime/CommandKitPluginRuntime';
 
 export interface CommandKitConfiguration {
   defaultLocale: Locale;
@@ -35,8 +36,9 @@ export class CommandKit extends EventEmitter {
 
   public commandsRouter!: CommandsRouter;
   public eventsRouter!: EventsRouter;
-  public commandHandler = new AppCommandHandler(this);
-  public eventHandler = new AppEventsHandler(this);
+  public readonly commandHandler = new AppCommandHandler(this);
+  public readonly eventHandler = new AppEventsHandler(this);
+  public readonly plugins: CommandKitPluginRuntime;
 
   static instance: CommandKit | undefined = undefined;
 
@@ -81,6 +83,7 @@ export class CommandKit extends EventEmitter {
     }
 
     this.eventInterceptor = new EventInterceptor(options.client);
+    this.plugins = new CommandKitPluginRuntime(this);
 
     if (!CommandKit.instance) {
       CommandKit.instance = this;

packages/commandkit/src/app/commands/Context.ts

@@ -176,7 +176,7 @@ export class Context<
    * @param command The command to forward to.
    */
   public async forwardCommand(command: string): Promise<never> {
-    const target = await this.commandkit.appCommandsHandler.prepareCommandRun(
+    const target = await this.commandkit.commandHandler.prepareCommandRun(
       (this.isInteraction() ? this.interaction : this.message) as Interaction,
     );
 

packages/commandkit/src/app/handlers/AppCommandHandler.ts

@@ -1,20 +1,29 @@
 import type { CommandKit } from '../../CommandKit';
 import {
   Awaitable,
+  ChatInputCommandInteraction,
   Collection,
   ContextMenuCommandBuilder,
+  Events,
   Interaction,
   Locale,
   Message,
+  PartialMessage,
   SlashCommandBuilder,
 } from 'discord.js';
-import { Context } from '../commands/Context';
+import {
+  CommandExecutionMode,
+  Context,
+  MiddlewareContext,
+} from '../commands/Context';
 import { toFileURL } from '../../utils/resolve-file-url';
 import { TranslatableCommandOptions } from '../i18n/Translation';
 import { MessageCommandParser } from '../commands/MessageCommandParser';
 import { CommandKitErrorCodes, isErrorType } from '../../utils/error-codes';
 import { ParsedCommand, ParsedMiddleware } from '../router';
 import { CommandRegistrar } from '../register/CommandRegistrar';
+import { GenericFunction } from '../../context/async-context';
+import { Logger } from '../../logger/Logger';
 
 interface AppCommand {
   command: SlashCommandBuilder | Record<string, any>;
@@ -73,6 +82,11 @@ export class AppCommandHandler {
   private loadedCommands = new Collection<string, LoadedCommand>();
   private loadedMiddlewares = new Collection<string, LoadedMiddleware>();
   public readonly registrar: CommandRegistrar;
+  private onInteraction: GenericFunction<[Interaction]> | null = null;
+  private onMessageCreate: GenericFunction<[Message]> | null = null;
+  private onMessageUpdate: GenericFunction<
+    [Message | PartialMessage, Message | PartialMessage]
+  > | null = null;
 
   public constructor(public readonly commandkit: CommandKit) {
     this.registrar = new CommandRegistrar(this.commandkit);
@@ -83,6 +97,154 @@ export class AppCommandHandler {
     return loaded;
   }
 
+  public registerCommandHandler() {
+    this.onInteraction ??= async (interaction: Interaction) => {
+      const success = await this.commandkit.plugins.execute(
+        async (ctx, plugin) => {
+          return plugin.onBeforeInteraction(ctx, interaction);
+        },
+      );
+
+      // plugin will handle the interaction
+      if (success) return;
+
+      const isCommandLike =
+        interaction.isCommand() ||
+        interaction.isAutocomplete() ||
+        interaction.isUserContextMenuCommand() ||
+        interaction.isMessageContextMenuCommand();
+
+      if (!isCommandLike) return;
+
+      const command = await this.prepareCommandRun(interaction);
+
+      if (!command) return;
+
+      return this.runCommand(command, interaction);
+    };
+
+    this.onMessageCreate ??= async (message: Message) => {
+      const success = await this.commandkit.plugins.execute(
+        async (ctx, plugin) => {
+          return plugin.onBeforeMessageCommand(ctx, message);
+        },
+      );
+
+      // plugin will handle the message
+      if (success) return;
+      if (message.author.bot) return;
+
+      const command = await this.prepareCommandRun(message);
+
+      if (!command) return;
+
+      return this.runCommand(command, message);
+    };
+
+    this.onMessageUpdate ??= async (
+      oldMessage: Message | PartialMessage,
+      newMessage: Message | PartialMessage,
+    ) => {
+      const success = await this.commandkit.plugins.execute(
+        async (ctx, plugin) => {
+          return plugin.onBeforeMessageUpdateCommand(
+            ctx,
+            oldMessage,
+            newMessage,
+          );
+        },
+      );
+
+      // plugin will handle the message
+      if (success) return;
+      if (oldMessage.partial || newMessage.partial) return;
+      if (oldMessage.author.bot) return;
+
+      const command = await this.prepareCommandRun(newMessage);
+
+      if (!command) return;
+
+      return this.runCommand(command, newMessage);
+    };
+
+    this.commandkit.client.on(Events.InteractionCreate, this.onInteraction);
+    this.commandkit.client.on(Events.MessageCreate, this.onMessageCreate);
+    this.commandkit.client.on(Events.MessageUpdate, this.onMessageUpdate);
+  }
+
+  public getExecutionMode(source: Interaction | Message): CommandExecutionMode {
+    if (source instanceof Message) return CommandExecutionMode.Message;
+    if (source.isChatInputCommand()) return CommandExecutionMode.SlashCommand;
+    if (source.isAutocomplete()) {
+      return CommandExecutionMode.Autocomplete;
+    }
+    if (source.isMessageContextMenuCommand()) {
+      return CommandExecutionMode.MessageContextMenu;
+    }
+    if (source.isUserContextMenuCommand()) {
+      return CommandExecutionMode.UserContextMenu;
+    }
+
+    return null as never;
+  }
+
+  public async runCommand(
+    command: PreparedAppCommandExecution,
+    source: Interaction | Message,
+  ) {
+    if (
+      source instanceof Message &&
+      (source.editedTimestamp || source.partial)
+    ) {
+      // TODO: handle message edit
+      return;
+    }
+
+    const executionMode = this.getExecutionMode(source);
+
+    const ctx = new MiddlewareContext(this.commandkit, {
+      executionMode,
+      interaction: !(source instanceof Message)
+        ? (source as ChatInputCommandInteraction)
+        : (null as never),
+      message: source instanceof Message ? source : (null as never),
+      forwarded: false,
+    });
+
+    for (const middleware of command.middlewares) {
+      await middleware.data.beforeExecute(ctx);
+    }
+
+    const fn = command.command.data[executionMode];
+
+    if (!fn) {
+      Logger.warn(
+        `Command ${command.command.command.name} has no handler for ${executionMode}`,
+      );
+    }
+
+    if (fn) {
+      try {
+        const executeCommand = async () => fn(ctx.clone());
+        const res = await this.commandkit.plugins.execute(
+          async (ctx, plugin) => {
+            return plugin.executeCommand(ctx, source, command, executeCommand);
+          },
+        );
+
+        if (!res) {
+          await executeCommand();
+        }
+      } catch (e) {
+        Logger.error(e);
+      }
+    }
+
+    for (const middleware of command.middlewares) {
+      await middleware.data.afterExecute(ctx);
+    }
+  }
+
   public async prepareCommandRun(
     source: Interaction | Message,
   ): Promise<PreparedAppCommandExecution | null> {

packages/commandkit/src/plugins/CompilerPlugin.ts

@@ -6,6 +6,7 @@ import {
 } from './runtime/types';
 import { PluginCommon, PluginOptions } from './PluginCommon';
 import { MaybeFalsey } from './types';
+import { CompilerPluginRuntime } from './runtime/CompilerPluginRuntime';
 
 export interface PluginTransformParameters {
   args: OnLoadArgs;
@@ -26,7 +27,7 @@ export interface ResolveResult {
 
 export abstract class CompilerPlugin<
   T extends PluginOptions = PluginOptions,
-> extends PluginCommon<T> {
+> extends PluginCommon<T, CompilerPluginRuntime> {
   /**
    * Called when transformation is requested to this plugin
    * @param params The parameters for the transformation

packages/commandkit/src/plugins/PluginCommon.ts

@@ -1,20 +1,23 @@
-import { ResolvedCommandKitConfig } from '../config';
+import { CommonPluginRuntime } from './runtime/runtime';
 
 export type PluginOptions = Record<string, any>;
 
-export abstract class PluginCommon<T extends PluginOptions> {
+export abstract class PluginCommon<
+  T extends PluginOptions,
+  C extends CommonPluginRuntime = CommonPluginRuntime,
+> {
   public abstract readonly name: string;
   public constructor(protected readonly options: T) {}
 
   /**
    * Called when this plugin is activated
    */
-  public async activate(config: ResolvedCommandKitConfig): Promise<void> {}
+  public async activate(ctx: C): Promise<void> {}
 
   /**
    * Called when this plugin is deactivated
    */
-  public async deactivate(config: ResolvedCommandKitConfig): Promise<void> {}
+  public async deactivate(ctx: C): Promise<void> {}
 }
 
 export function isPlugin(

packages/commandkit/src/plugins/RuntimePlugin.ts

@@ -1,44 +1,102 @@
+import { Interaction, Message, PartialMessage } from 'discord.js';
 import { PluginCommon, PluginOptions } from './PluginCommon';
-import { CommandKit } from '../CommandKit';
+import type { CommandKitPluginRuntime } from './runtime/CommandKitPluginRuntime';
+import { PreparedAppCommandExecution } from '../app';
 
 export abstract class RuntimePlugin<
   T extends PluginOptions = PluginOptions,
-> extends PluginCommon<T> {
+> extends PluginCommon<T, CommandKitPluginRuntime> {
   /**
    * Called before commands are loaded
-   * @param commandkit The commandkit instance
    */
-  public async onBeforeCommandsLoad(commandkit: CommandKit): Promise<void> {}
+  public async onBeforeCommandsLoad(
+    ctx: CommandKitPluginRuntime,
+  ): Promise<void> {}
 
   /**
    * Called after commands are loaded
-   * @param commandkit The commandkit instance
    */
-  public async onAfterCommandsLoad(commandkit: CommandKit): Promise<void> {}
+  public async onAfterCommandsLoad(
+    ctx: CommandKitPluginRuntime,
+  ): Promise<void> {}
 
   /**
    * Called before events are loaded
-   * @param commandkit The commandkit instance
    */
-  public async onBeforeEventsLoad(commandkit: CommandKit): Promise<void> {}
+  public async onBeforeEventsLoad(
+    ctx: CommandKitPluginRuntime,
+  ): Promise<void> {}
 
   /**
    * Called after events are loaded
-   * @param commandkit The commandkit instance
    */
-  public async onAfterEventsLoad(commandkit: CommandKit): Promise<void> {}
+  public async onAfterEventsLoad(ctx: CommandKitPluginRuntime): Promise<void> {}
 
   /**
    * Called before the client logs in
-   * @param commandkit The commandkit instance
    */
-  public async onBeforeClientLogin(commandkit: CommandKit): Promise<void> {}
+  public async onBeforeClientLogin(
+    ctx: CommandKitPluginRuntime,
+  ): Promise<void> {}
 
   /**
    * Called after the client logs in
-   * @param commandkit The commandkit instance
    */
-  public async onAfterClientLogin(commandkit: CommandKit): Promise<void> {}
+  public async onAfterClientLogin(
+    ctx: CommandKitPluginRuntime,
+  ): Promise<void> {}
+
+  /**
+   * Called before interaction is handled
+   * @param interaction The interaction
+   */
+  public async onBeforeInteraction(
+    ctx: CommandKitPluginRuntime,
+    interaction: Interaction,
+  ): Promise<void> {}
+
+  /**
+   * Called after interaction is handled
+   * @param interaction The interaction that was handled
+   */
+  public async onAfterInteraction(
+    ctx: CommandKitPluginRuntime,
+    interaction: Interaction,
+  ): Promise<void> {}
+
+  /**
+   * Called before message command is processed
+   * @param message The message
+   */
+  public async onBeforeMessageCommand(
+    ctx: CommandKitPluginRuntime,
+    message: Message,
+  ): Promise<void> {}
+
+  /**
+   * Called before message update command is processed
+   * @param message The message
+   */
+  public async onBeforeMessageUpdateCommand(
+    ctx: CommandKitPluginRuntime,
+    oldMessage: Message | PartialMessage,
+    newMessage: Message | PartialMessage,
+  ): Promise<void> {}
+
+  /**
+   * Called before command is executed. This method can execute the command itself.
+   * @param source The source that triggered the command
+   * @param command The command
+   * @param execute The function that executes the command
+   */
+  public async executeCommand(
+    ctx: CommandKitPluginRuntime,
+    source: Interaction | Message,
+    command: PreparedAppCommandExecution,
+    execute: () => Promise<any>,
+  ): Promise<boolean> {
+    return false;
+  }
 }
 
 export function isRuntimePlugin(plugin: unknown): plugin is RuntimePlugin {