Replaces explicit command registration w/ @command

Author: eamodio

src/env/node/gk/cli/commands.ts

@@ -5,56 +5,26 @@ import type { Container } from '../../../../container';
 import { cherryPick, merge, rebase } from '../../../../git/actions/repository';
 import type { Repository } from '../../../../git/models/repository';
 import { executeCommand } from '../../../../system/-webview/command';
+import { createCommandDecorator } from '../../../../system/decorators/command';
 import type { CliCommandRequest, CliCommandResponse, CliIpcServer } from './integration';
 
-interface CliCommand {
-	command: string;
-	handler: (request: CliCommandRequest, repo?: Repository | undefined) => Promise<CliCommandResponse>;
-}
-
-const commandHandlers: CliCommand[] = [];
-function command(command: string) {
-	return function (
-		target: unknown,
-		contextOrKey?: string | ClassMethodDecoratorContext,
-		descriptor?: PropertyDescriptor,
-	) {
-		// ES Decorator
-		if (contextOrKey && typeof contextOrKey === 'object' && 'kind' in contextOrKey) {
-			if (contextOrKey.kind !== 'method') {
-				throw new Error('The command decorator can only be applied to methods');
-			}
+type CliCommandHandler = (request: CliCommandRequest, repo?: Repository | undefined) => Promise<CliCommandResponse>;
 
-			commandHandlers.push({ command: command, handler: target as CliCommand['handler'] });
-			return;
-		}
-
-		// TypeScript experimental decorator
-		if (descriptor) {
-			commandHandlers.push({ command: command, handler: descriptor.value as CliCommand['handler'] });
-			return descriptor;
-		}
-
-		throw new Error('Invalid decorator usage');
-	};
-}
+const { command, getCommands } = createCommandDecorator<CliCommandHandler>();
 
 export class CliCommandHandlers implements Disposable {
 	constructor(
 		private readonly container: Container,
 		private readonly server: CliIpcServer,
 	) {
-		for (const { command, handler } of commandHandlers) {
+		for (const { command, handler } of getCommands()) {
 			this.server.registerHandler(command, rq => this.wrapHandler(rq, handler));
 		}
 	}
 
 	dispose(): void {}
 
-	private wrapHandler(
-		request: CliCommandRequest,
-		handler: (request: CliCommandRequest, repo?: Repository | undefined) => Promise<CliCommandResponse>,
-	) {
+	private wrapHandler(request: CliCommandRequest, handler: CliCommandHandler) {
 		let repo: Repository | undefined;
 		if (request?.cwd) {
 			repo = this.container.git.getRepository(request.cwd);

src/system/decorators/command.ts

@@ -0,0 +1,68 @@
+interface Command<
+	THandler extends (...args: any[]) => any,
+	TCommand extends string = string,
+	TOptions extends object | void = void,
+> {
+	command: TCommand;
+	handler: THandler;
+	options?: TOptions;
+}
+
+export function createCommandDecorator<
+	THandler extends (...args: any[]) => any = (...args: any[]) => any,
+	TCommand extends string = string,
+	TOptions extends object | void = void,
+>(): {
+	command: (
+		command: TCommand,
+		options?: TOptions,
+	) => (
+		target: unknown,
+		contextOrKey?: string | ClassMethodDecoratorContext,
+		descriptor?: PropertyDescriptor,
+	) => PropertyDescriptor | undefined;
+	getCommands: () => Iterable<Command<THandler, TCommand, TOptions>>;
+} {
+	const commands = new Map<string, Command<THandler, TCommand, TOptions>>();
+
+	function command(command: TCommand, options?: TOptions) {
+		return function (
+			target: unknown,
+			contextOrKey?: string | ClassMethodDecoratorContext,
+			descriptor?: PropertyDescriptor,
+		) {
+			if (commands.has(command)) {
+				debugger;
+				throw new Error(`@command decorator has already been applied to the command: ${command}`);
+			}
+
+			// ES Decorator
+			if (contextOrKey && typeof contextOrKey === 'object' && 'kind' in contextOrKey) {
+				if (contextOrKey.kind !== 'method') {
+					// eslint-disable-next-line @typescript-eslint/restrict-template-expressions
+					throw new Error(`@command can only be used on methods, not on ${contextOrKey.kind}`);
+				}
+
+				commands.set(command, { command: command, handler: target as THandler, options: options });
+				return;
+			}
+
+			// TypeScript experimental decorator
+			if (descriptor) {
+				if (typeof descriptor.value !== 'function') {
+					throw new Error(`@command can only be used on methods, not on ${typeof descriptor.value}`);
+				}
+
+				commands.set(command, { command: command, handler: descriptor.value as THandler, options: options });
+				return descriptor;
+			}
+
+			throw new Error('Invalid decorator usage');
+		};
+	}
+
+	return {
+		command: command,
+		getCommands: () => commands.values(),
+	};
+}