feat(ContextMenus): add context menu command builder (#29)

Co-authored-by: Nicholas Christopher <nicholaschristopher@protonmail.com>
Co-authored-by: Keenser1 <36800359+Keenser1@users.noreply.github.com>
Co-authored-by: Noel <buechler.noel@outlook.com>

Author: 3 people

src/index.ts

@@ -13,3 +13,6 @@ export * from './interactions/slashCommands/options/number';
 export * from './interactions/slashCommands/options/role';
 export * from './interactions/slashCommands/options/string';
 export * from './interactions/slashCommands/options/user';
+
+export * as ContextMenuCommandAssertions from './interactions/contextMenuCommands/Assertions';
+export * from './interactions/contextMenuCommands/ContextMenuCommandBuilder';

src/interactions/contextMenuCommands/Assertions.ts

@@ -0,0 +1,32 @@
+import ow from 'ow';
+import { ApplicationCommandType } from 'discord-api-types/v9';
+import type { ContextMenuCommandType } from './ContextMenuCommandBuilder';
+
+export function validateRequiredParameters(name: string, type: number) {
+	// Assert name matches all conditions
+	validateName(name);
+
+	// Assert type is valid
+	validateType(type);
+}
+
+const namePredicate = ow.string
+	.minLength(1)
+	.maxLength(32)
+	.matches(/^( *[\p{L}\p{N}_-]+ *)+$/u);
+
+export function validateName(name: unknown): asserts name is string {
+	ow(name, 'name', namePredicate);
+}
+
+const typePredicate = ow.number.oneOf([ApplicationCommandType.User, ApplicationCommandType.Message]);
+
+export function validateType(type: unknown): asserts type is ContextMenuCommandType {
+	ow(type, 'type', typePredicate);
+}
+
+const defaultPermissionPredicate = ow.boolean;
+
+export function validateDefaultPermission(value: unknown): asserts value is boolean {
+	ow(value, 'default_permission', defaultPermissionPredicate);
+}

src/interactions/contextMenuCommands/ContextMenuCommandBuilder.ts

@@ -0,0 +1,79 @@
+import { validateRequiredParameters, validateName, validateType, validateDefaultPermission } from './Assertions';
+import type { ApplicationCommandType, RESTPostAPIApplicationCommandsJSONBody } from 'discord-api-types/v9';
+
+export class ContextMenuCommandBuilder {
+	/**
+	 * The name of this context menu command
+	 */
+	public readonly name: string = undefined!;
+
+	/**
+	 * The type of this context menu command
+	 */
+	public readonly type: ContextMenuCommandType = undefined!;
+
+	/**
+	 * Whether the command is enabled by default when the app is added to a guild
+	 * @default true
+	 */
+	public readonly defaultPermission: boolean | undefined = undefined;
+
+	/**
+	 * Sets the name
+	 * @param name The name
+	 */
+	public setName(name: string) {
+		// Assert the name matches the conditions
+		validateName(name);
+
+		Reflect.set(this, 'name', name);
+
+		return this;
+	}
+
+	/**
+	 * Sets the type
+	 * @param type The type
+	 */
+	public setType(type: ContextMenuCommandType) {
+		// Assert the type is valid
+		validateType(type);
+
+		Reflect.set(this, 'type', type);
+
+		return this;
+	}
+
+	/**
+	 * Sets whether the command is enabled by default when the application is added to a guild.
+	 *
+	 * **Note**: If set to `false`, you will have to later `PUT` the permissions for this command.
+	 * @param value Whether or not to enable this command by default
+	 *
+	 * @see https://discord.com/developers/docs/interactions/application-commands#permissions
+	 */
+	public setDefaultPermission(value: boolean) {
+		// Assert the value matches the conditions
+		validateDefaultPermission(value);
+
+		Reflect.set(this, 'defaultPermission', value);
+
+		return this;
+	}
+
+	/**
+	 * Returns the final data that should be sent to Discord.
+	 *
+	 * **Note:** Calling this function will validate required properties based on their conditions.
+	 */
+	public toJSON(): RESTPostAPIApplicationCommandsJSONBody {
+		validateRequiredParameters(this.name, this.type);
+		return {
+			name: this.name,
+			type: this.type,
+			default_permission: this.defaultPermission,
+		};
+	}
+}
+
+export type ContextMenuCommandType = ApplicationCommandType.User | ApplicationCommandType.Message;

src/interactions/slashCommands/SlashCommandBuilder.ts

@@ -51,10 +51,10 @@ export class SlashCommandBuilder {
 	/**
 	 * Sets whether the command is enabled by default when the application is added to a guild.
 	 *
-	 * **Note**: If set to `false`, you will have to later have to `PUT` the permissions for this command.
+	 * **Note**: If set to `false`, you will have to later `PUT` the permissions for this command.
 	 * @param value Whether or not to enable this command by default
 	 *
-	 * @see https://discord.com/developers/docs/interactions/slash-commands#permissions
+	 * @see https://discord.com/developers/docs/interactions/application-commands#permissions
 	 */
 	public setDefaultPermission(value: boolean) {
 		// Assert the value matches the conditions

tests/ContextMenuCommands.test.ts

@@ -0,0 +1,89 @@
+import { ContextMenuCommandAssertions, ContextMenuCommandBuilder } from '../src/index';
+
+const getBuilder = () => new ContextMenuCommandBuilder();
+
+describe('Context Menu Commands', () => {
+	describe('Assertions tests', () => {
+		test('GIVEN valid name THEN does not throw error', () => {
+			expect(() => ContextMenuCommandAssertions.validateName('ping')).not.toThrowError();
+		});
+
+		test('GIVEN invalid name THEN throw error', () => {
+			expect(() => ContextMenuCommandAssertions.validateName(null)).toThrowError();
+
+			// Too short of a name
+			expect(() => ContextMenuCommandAssertions.validateName('')).toThrowError();
+
+			// Invalid characters used
+			expect(() => ContextMenuCommandAssertions.validateName('ABC123$%^&')).toThrowError();
+
+			// Too long of a name
+			expect(() =>
+				ContextMenuCommandAssertions.validateName('qwertyuiopasdfghjklzxcvbnmqwertyuiopasdfghjklzxcvbnm'),
+			).toThrowError();
+		});
+
+		test('GIVEN valid type THEN does not throw error', () => {
+			expect(() => ContextMenuCommandAssertions.validateType(3)).not.toThrowError();
+		});
+
+		test('GIVEN invalid type THEN throw error', () => {
+			expect(() => ContextMenuCommandAssertions.validateType(null)).toThrowError();
+
+			// Out of range
+			expect(() => ContextMenuCommandAssertions.validateType(1)).toThrowError();
+		});
+
+		test('GIVEN valid required parameters THEN does not throw error', () => {
+			expect(() => ContextMenuCommandAssertions.validateRequiredParameters('owo', 2)).not.toThrowError();
+		});
+
+		test('GIVEN valid default_permission THEN does not throw error', () => {
+			expect(() => ContextMenuCommandAssertions.validateDefaultPermission(true)).not.toThrowError();
+		});
+
+		test('GIVEN invalid default_permission THEN throw error', () => {
+			expect(() => ContextMenuCommandAssertions.validateDefaultPermission(null)).toThrowError();
+		});
+	});
+
+	describe('ContextMenuCommandBuilder', () => {
+		describe('Builder tests', () => {
+			test('GIVEN empty builder THEN throw error when calling toJSON', () => {
+				expect(() => getBuilder().toJSON()).toThrowError();
+			});
+
+			test('GIVEN valid builder THEN does not throw error', () => {
+				expect(() => getBuilder().setName('example').setType(3).toJSON()).not.toThrowError();
+			});
+
+			test('GIVEN invalid name THEN throw error', () => {
+				expect(() => getBuilder().setName('$$$')).toThrowError();
+
+				expect(() => getBuilder().setName(' ')).toThrowError();
+			});
+
+			test('GIVEN valid names THEN does not throw error', () => {
+				expect(() => getBuilder().setName('hi_there')).not.toThrowError();
+
+				expect(() => getBuilder().setName('A COMMAND')).not.toThrowError();
+
+				// Translation: a_command
+				expect(() => getBuilder().setName('o_comandă')).not.toThrowError();
+
+				// Translation: thx (according to GTranslate)
+				expect(() => getBuilder().setName('どうも')).not.toThrowError();
+			});
+
+			test('GIVEN valid types THEN does not throw error', () => {
+				expect(() => getBuilder().setType(2)).not.toThrowError();
+
+				expect(() => getBuilder().setType(3)).not.toThrowError();
+			});
+
+			test('GIVEN valid builder with defaultPermission false THEN does not throw error', () => {
+				expect(() => getBuilder().setName('foo').setDefaultPermission(false)).not.toThrowError();
+			});
+		});
+	});
+});