refactor(rpc-methods): Force all implementations to be async

Author: rekmarks

packages/rpc-methods/src/RpcService.test.ts

@@ -27,28 +27,28 @@ describe('RpcService', () => {
   });
 
   describe('execute', () => {
-    it('should be able to execute a method', () => {
+    it('should execute a method', async () => {
       const service = new RpcService(getHandlers(), getHooks());
-      expect(service.execute('method1', ['test'])).toBeNull();
+      expect(await service.execute('method1', ['test'])).toBeNull();
     });
 
-    it('should be able to execute a method that uses a hook', () => {
+    it('should be able to execute a method that uses a hook', async () => {
       const service = new RpcService(getHandlers(), getHooks());
-      expect(service.execute('method2', [2])).toBe(4);
+      expect(await service.execute('method2', [2])).toBe(4);
     });
 
-    it('should throw an error if the method is not found', () => {
+    it('should throw an error if the method is not found', async () => {
       const service = new RpcService(getHandlers(), getHooks());
       // @ts-expect-error Intentional destructive testing
-      expect(async () => service.execute('method3', [2])).not.toThrow(
+      await expect(service.execute('method3', [2])).rejects.toThrow(
         // This is not a _good_ error, but we only care about type safety in this instance.
-        'TypeError: Cannot read properties of undefined (reading "params")',
+        "Cannot read properties of undefined (reading 'params')",
       );
     });
 
-    it('should throw if passed invalid params', () => {
+    it('should throw if passed invalid params', async () => {
       const service = new RpcService(getHandlers(), getHooks());
-      expect(async () => service.execute('method1', [2])).toThrow(
+      await expect(service.execute('method1', [2])).rejects.toThrow(
         'Invalid params',
       );
     });

packages/rpc-methods/src/RpcService.ts

@@ -77,18 +77,18 @@ export class RpcService<
    * @returns The result of the method execution.
    * @throws If the parameters are invalid.
    */
-  execute<Method extends ExtractMethods<Handlers[keyof Handlers]>>(
+  async execute<Method extends ExtractMethods<Handlers[keyof Handlers]>>(
     method: Method,
     params: unknown,
-  ): ReturnType<Handlers[Method]['implementation']> {
+  ): Promise<ReturnType<Handlers[Method]['implementation']>> {
     const handler = this.#getHandler(method);
     assertParams(params, handler.params);
 
     // Select only the hooks that the handler needs
     const selectedHooks = selectHooks(this.#hooks, handler.hooks);
 
     // Execute the handler with the selected hooks
-    return handler.implementation(selectedHooks, params);
+    return await handler.implementation(selectedHooks, params);
   }
 
   /**

packages/rpc-methods/src/utils.ts

@@ -57,7 +57,7 @@ export type HandlerFunction<
   Params extends JsonRpcParams,
   Result extends Json,
   Hooks extends Record<string, unknown>,
-> = (hooks: Hooks, params: Params) => Result | Promise<Result>;
+> = (hooks: Hooks, params: Params) => Promise<Result>;
 
 // Service-side types
 

packages/rpc-methods/test/methods.ts

@@ -30,7 +30,7 @@ export const getPartialHandlers = () =>
   ({
     method1: {
       method: 'method1',
-      implementation: (hooks, [_value]) => {
+      implementation: async (hooks, [_value]) => {
         hooks.hook1();
         return null;
       },
@@ -43,7 +43,7 @@ export const getPartialHandlers = () =>
     >,
     method2: {
       method: 'method2',
-      implementation: (hooks, [value]) => {
+      implementation: async (hooks, [value]) => {
         hooks.hook3();
         return value * 2;
       },