(WIP) Make Handler more type-safe

src/builders.ts

@@ -37,7 +37,7 @@ const { name: PACKAGE_NAME } = require('../package.json');
 /** Either a Builder or a function that returns a Builder. */
 export type BuilderInput<T> = T | ((thing: T) => T);
 /** The function called during command execution. */
-export type Handler = (interaction: Discord.CommandInteraction) => unknown;
+export type Handler<T extends Discord.BaseInteraction> = (interaction: T) => unknown;
 /** A string option with the length set internally. */
 export type SlashCommandCustomOption = Omit<Discord.SlashCommandStringOption,
 	'setMinLength' | 'setMaxLength'
@@ -82,12 +82,12 @@ class MoreOptionsMixin extends Discord.SharedSlashCommandOptions {
 }
 
 /** Mixin that adds the ability to set and store a command handler function. */
-class CommandHandlerMixin {
+class CommandHandlerMixin<T extends Discord.BaseInteraction> {
 	/** The function called when this command is executed. */
-	public readonly handler: Handler | undefined;
+	public readonly handler: Handler<T> | undefined;
 
 	/** Sets the function called when this command is executed. */
-	setHandler(handler: Handler): this {
+	setHandler(handler: Handler<T>): this {
 		if (typeof handler !== 'function') {
 			throw new Error(`handler was '${typeof handler}', expected 'function'`);
 		}
@@ -116,12 +116,15 @@ type SlashCommandSubcommandsOnlyBuilder = Omit<SlashCommandBuilder,
 // Otherwise, we run the risk of stepping on field initialization.
 
 export class ContextMenuCommandBuilder extends Mixin(
-	CommandHandlerMixin,
+	// This double mixin is dumb, but it's the only way to accept both
+	// ContextMenuCommandInteraction types.
+	CommandHandlerMixin<Discord.UserContextMenuCommandInteraction>,
+	CommandHandlerMixin<Discord.MessageContextMenuCommandInteraction>,
 	Discord.ContextMenuCommandBuilder,
 ) {}
 
 export class SlashCommandBuilder extends Mixin(
-	CommandHandlerMixin,
+	CommandHandlerMixin<Discord.ChatInputCommandInteraction>,
 	MoreOptionsMixin,
 	Discord.SlashCommandBuilder,
 ) {
@@ -149,7 +152,7 @@ export class SlashCommandBuilder extends Mixin(
 }
 
 export class SlashCommandSubcommandGroupBuilder extends Mixin(
-	CommandHandlerMixin,
+	CommandHandlerMixin<Discord.ChatInputCommandInteraction>,
 	Discord.SlashCommandSubcommandGroupBuilder,
 ) {
 	// @ts-ignore We want to force this to only accept our version of the
@@ -164,7 +167,7 @@ export class SlashCommandSubcommandGroupBuilder extends Mixin(
 
 export class SlashCommandSubcommandBuilder extends Mixin(
 	MoreOptionsMixin,
-	CommandHandlerMixin,
+	CommandHandlerMixin<Discord.ChatInputCommandInteraction>,
 	Discord.SlashCommandSubcommandBuilder,
 ) {}
 

src/registry.ts

@@ -10,6 +10,7 @@
 import {
 	BaseInteraction,
 	ChatInputCommandInteraction,
+	CommandInteraction,
 	ContextMenuCommandInteraction,
 	DiscordAPIError,
 	ContextMenuCommandBuilder as DiscordContextMenuCommandBuilder,
@@ -19,7 +20,6 @@ import {
 	Snowflake,
 	RESTPostAPIContextMenuApplicationCommandsJSONBody,
 	RESTPostAPIChatInputApplicationCommandsJSONBody,
-	CommandInteraction,
 } from 'discord.js';
 
 import {
@@ -77,7 +77,7 @@ export default class SlashCommandRegistry {
 	application_id: Snowflake | null = null;
 
 	/** The handler run for unrecognized commands. */
-	default_handler: Handler | null = null;
+	default_handler: Handler<BaseInteraction> | null = null;
 
 	/** A Discord guild ID used to restrict command registration to one guild. */
 	guild_id: Snowflake | null = null;
@@ -154,7 +154,7 @@ export default class SlashCommandRegistry {
 	 * @throws If handler is not a function.
 	 * @return Instance so we can chain calls.
 	 */
-	setDefaultHandler(handler: Handler): this {
+	setDefaultHandler(handler: Handler<BaseInteraction>): this {
 		if (typeof handler !== 'function') {
 			throw new Error(`handler was '${typeof handler}', expected 'function'`);
 		}
@@ -297,6 +297,11 @@ export default class SlashCommandRegistry {
 			builder_top.handler    ??
 			this.default_handler;
 
+		// @ts-expect-error Discord.js Interaction types are mutually exclusive,
+		// despite all extending BaseInteraction. We do our best to make sure
+		// each individual handler is the right type, but the union of all of
+		// them here resolves to "never".
+		// https://discord.com/channels/222078108977594368/824411059443204127/1145960025962066033
 		return handler ? handler(interaction) as T : undefined;
 	}
 

test/builders.test.ts

@@ -17,16 +17,30 @@ import {
 	SlashCommandBuilder,
 	SlashCommandSubcommandBuilder,
 	SlashCommandSubcommandGroupBuilder,
+	SlashCommandRegistry,
 } from '../src';
 import { BuilderInput } from '../src/builders';
 
 type CanSetHandler = new () => {
-	setHandler: (handler: Handler) => unknown;
+	setHandler: (handler: Handler<Discord.BaseInteraction>) => unknown;
 }
 type CanAddSubCommand = new () => {
 	addSubcommand: (input: BuilderInput<SlashCommandSubcommandBuilder>) => unknown;
 };
 
+// These are static type tests to ensure Handler can accept all of these types.
+new SlashCommandRegistry()
+	.addContextMenuCommand(cmd => cmd
+		.setType(Discord.ApplicationCommandType.User)
+		.setHandler((int: Discord.UserContextMenuCommandInteraction) => {})
+		.setHandler((int: Discord.MessageContextMenuCommandInteraction) => {})
+	)
+	.addCommand(cmd => cmd
+		.setHandler((int: Discord.CommandInteraction) => {})
+		.setHandler((int: Discord.ChatInputCommandInteraction) => {})
+	)
+	.setDefaultHandler((int: Discord.BaseInteraction) => {})
+
 describe('Builders have setHandler() functions injected', function() {
 	Array.of<CanSetHandler>(
 		ContextMenuCommandBuilder,

test/mock.ts

@@ -71,6 +71,7 @@ export class MockCommandInteraction extends ChatInputCommandInteraction {
 				username: 'fake_test_user',
 				discriminator: '1234',
 				avatar: null,
+				global_name: null,
 			},
 		});