refactor: unify resolver registration by replacing onQuery and onMutation with a single resolver method

Author: arnabrahman

packages/event-handler/src/appsync-graphql/AppSyncGraphQLResolver.ts

@@ -108,32 +108,24 @@ export class AppSyncGraphQLResolver extends Router {
   }
 
   /**
-   * Executes the appropriate resolver (query or mutation) for a given AppSync GraphQL event.
+   * Executes the appropriate resolver for a given AppSync GraphQL event.
    *
    * This method attempts to resolve the handler for the specified field and type name
-   * from the query and mutation registries. If a matching handler is found, it invokes
-   * the handler with the event arguments. If no handler is found, it throws a
-   * `ResolverNotFoundException`.
+   * from the resolver registry. If a matching handler is found, it invokes the handler
+   * with the event arguments. If no handler is found, it throws a `ResolverNotFoundException`.
    *
    * @param event - The AppSync GraphQL event containing resolver information.
    * @throws {ResolverNotFoundException} If no resolver is registered for the given field and type.
    */
   async #executeSingleResolver(event: AppSyncGraphQLEvent): Promise<unknown> {
     const { fieldName, parentTypeName: typeName } = event.info;
-    const queryHandlerOptions = this.onQueryRegistry.resolve(
-      typeName,
-      fieldName
-    );
-    if (queryHandlerOptions) {
-      return await queryHandlerOptions.handler.apply(this, [event.arguments]);
-    }
 
-    const mutationHandlerOptions = this.onMutationRegistry.resolve(
+    const resolverHandlerOptions = this.resolverRegistry.resolve(
       typeName,
       fieldName
     );
-    if (mutationHandlerOptions) {
-      return await mutationHandlerOptions.handler.apply(this, [
+    if (resolverHandlerOptions) {
+      return await resolverHandlerOptions.handler.apply(this, [
         event.arguments,
       ]);
     }

packages/event-handler/src/appsync-graphql/RouteHandlerRegistry.ts

@@ -5,7 +5,7 @@ import type {
 } from '../types/appsync-graphql.js';
 
 /**
- * Registry for storing route handlers for the `query` and `mutation` events in AWS AppSync GraphQL API's.
+ * Registry for storing route handlers for GraphQL resolvers in AWS AppSync GraphQL API's.
  *
  * This class should not be used directly unless you are implementing a custom router.
  * Instead, use the {@link Router} class, which is the recommended way to register routes.
@@ -19,14 +19,9 @@ class RouteHandlerRegistry {
    * A logger instance to be used for logging debug and warning messages.
    */
   readonly #logger: GenericLogger;
-  /**
-   * The event type stored in the registry.
-   */
-  readonly #eventType: 'onQuery' | 'onMutation';
 
   public constructor(options: RouteHandlerRegistryOptions) {
     this.#logger = options.logger;
-    this.#eventType = options.eventType ?? 'onQuery';
   }
 
   /**
@@ -40,9 +35,7 @@ class RouteHandlerRegistry {
    */
   public register(options: RouteHandlerOptions): void {
     const { fieldName, handler, typeName } = options;
-    this.#logger.debug(
-      `Adding ${this.#eventType} resolver for field ${typeName}.${fieldName}`
-    );
+    this.#logger.debug(`Adding resolver for field ${typeName}.${fieldName}`);
     const cacheKey = this.#makeKey(typeName, fieldName);
     if (this.resolvers.has(cacheKey)) {
       this.#logger.warn(
@@ -67,7 +60,7 @@ class RouteHandlerRegistry {
     fieldName: string
   ): RouteHandlerOptions | undefined {
     this.#logger.debug(
-      `Looking for ${this.#eventType} resolver for type=${typeName}, field=${fieldName}`
+      `Looking for resolver for type=${typeName}, field=${fieldName}`
     );
     return this.resolvers.get(this.#makeKey(typeName, fieldName));
   }

packages/event-handler/src/appsync-graphql/Router.ts

@@ -1,29 +1,21 @@
-import {
-  EnvironmentVariablesService,
-  isRecord,
-} from '@aws-lambda-powertools/commons';
+import { EnvironmentVariablesService } from '@aws-lambda-powertools/commons';
 import type { GenericLogger } from '@aws-lambda-powertools/commons/types';
 import { getStringFromEnv } from '@aws-lambda-powertools/commons/utils/env';
 import type {
   GraphQlRouteOptions,
   GraphQlRouterOptions,
-  OnMutationHandler,
-  OnQueryHandler,
+  ResolverHandler,
 } from '../types/appsync-graphql.js';
 import { RouteHandlerRegistry } from './RouteHandlerRegistry.js';
 
 /**
- * Class for registering routes for the `query` and `mutation` events in AWS AppSync GraphQL APIs.
+ * Class for registering resolvers for GraphQL events in AWS AppSync GraphQL APIs.
  */
 class Router {
   /**
-   * A map of registered routes for the `query` event, keyed by their fieldNames.
+   * A map of registered routes for all GraphQL events, keyed by their fieldNames.
    */
-  protected readonly onQueryRegistry: RouteHandlerRegistry;
-  /**
-   * A map of registered routes for the `mutation` event, keyed by their fieldNames.
-   */
-  protected readonly onMutationRegistry: RouteHandlerRegistry;
+  protected readonly resolverRegistry: RouteHandlerRegistry;
   /**
    * A logger instance to be used for logging debug, warning, and error messages.
    *
@@ -50,133 +42,39 @@ class Router {
       error: console.error,
       warn: console.warn,
     };
-    this.onQueryRegistry = new RouteHandlerRegistry({
-      logger: this.logger,
-      eventType: 'onQuery',
-    });
-    this.onMutationRegistry = new RouteHandlerRegistry({
+    this.resolverRegistry = new RouteHandlerRegistry({
       logger: this.logger,
-      eventType: 'onMutation',
     });
     this.isDev = this.envService.isDevMode();
   }
 
   /**
-   * Register a handler function for the `query` event.
-   
-   * Registers a handler for a specific GraphQL Query field. The handler will be invoked when a request is made
-   * for the specified field in the Query type.
-   *   
-   * @example
-   * ```ts
-   * import { AppSyncGraphQLResolver } from '@aws-lambda-powertools/event-handler/appsync-graphql';
+   * Register a resolver function for any GraphQL event.
    *
-   * const app = new AppSyncGraphQLResolver();
+   * Registers a handler for a specific GraphQL field. The handler will be invoked when a request is made
+   * for the specified field.
    *
-   * app.onQuery('getPost', async (payload) => {
-   *   // your business logic here
-   *   return payload;
-   * });
-   
-   * export const handler = async (event, context) =>
-   *   app.resolve(event, context);
-   * ```
-   *
-   * You can also specify the type of the arguments using a generic type parameter:
-   * 
    * @example
    * ```ts
    * import { AppSyncGraphQLResolver } from '@aws-lambda-powertools/event-handler/appsync-graphql';
    *
    * const app = new AppSyncGraphQLResolver();
    *
-   * app.onQuery<{ postId: string }>('getPost', async ({ postId }) => {
-   *   // postId is now typed as string
-   *   return { id: postId };
+   * // Register a Query resolver
+   * app.resolver(async (payload) => {
+   *   // your business logic here
+   *   return payload;
+   * }, {
+   *   fieldName: 'getPost'
    * });
-   
-   * export const handler = async (event, context) =>
-   *   app.resolve(event, context);
-   * ```
-   *
-   * As a decorator:
-   *
-   * @example
-   * ```ts
-   * import { AppSyncGraphQLResolver } from '@aws-lambda-powertools/event-handler/appsync-graphql';
-   *
-   * const app = new AppSyncGraphQLResolver();
-   *
-   * class Lambda {
-   *   @app.onQuery('getPost')
-   *   async handleGetPost(payload) {
-   *     // your business logic here
-   *     return payload;
-   *   }
-   *
-   *   async handler(event, context) {
-   *     return app.resolve(event, context);
-   *   }
-   * }
    *
-   * const lambda = new Lambda();
-   * export const handler = lambda.handler.bind(lambda);
-   * ```
-   *
-   * @param fieldName - The name of the Query field to register the handler for.
-   * @param handler - The handler function to be called when the event is received.
-   * @param options - Optional route options.
-   * @param options.typeName - The name of the GraphQL type to use for the resolver (defaults to 'Query').
-   */
-  public onQuery<TParams extends Record<string, unknown>>(
-    fieldName: string,
-    handler: OnQueryHandler<TParams>,
-    options?: GraphQlRouteOptions
-  ): void;
-  public onQuery(
-    fieldName: string,
-    options?: GraphQlRouteOptions
-  ): MethodDecorator;
-  public onQuery<TParams extends Record<string, unknown>>(
-    fieldName: string,
-    handler?: OnQueryHandler<TParams> | GraphQlRouteOptions,
-    options?: GraphQlRouteOptions
-  ): MethodDecorator | undefined {
-    if (handler && typeof handler === 'function') {
-      this.onQueryRegistry.register({
-        fieldName,
-        handler: handler as OnQueryHandler<Record<string, unknown>>,
-        typeName: options?.typeName ?? 'Query',
-      });
-      return;
-    }
-
-    return (_target, _propertyKey, descriptor: PropertyDescriptor) => {
-      const routeOptions = isRecord(handler) ? handler : options;
-      this.onQueryRegistry.register({
-        fieldName,
-        handler: descriptor.value as OnQueryHandler<Record<string, unknown>>,
-        typeName: routeOptions?.typeName ?? 'Query',
-      });
-      return descriptor;
-    };
-  }
-
-  /**
-   * Register a handler function for the `mutation` event.
-   *
-   * Registers a handler for a specific GraphQL Mutation field. The handler will be invoked when a request is made
-   * for the specified field in the Mutation type.
-   *
-   * @example
-   * ```ts
-   * import { AppSyncGraphQLResolver } from '@aws-lambda-powertools/event-handler/appsync-graphql';
-   *
-   * const app = new AppSyncGraphQLResolver();
-   *
-   * app.onMutation('createPost', async (payload) => {
+   * // Register a Mutation resolver
+   * app.resolver(async (payload) => {
    *   // your business logic here
    *   return payload;
+   * }, {
+   *   fieldName: 'createPost',
+   *   typeName: 'Mutation'
    * });
    *
    * export const handler = async (event, context) =>
@@ -191,9 +89,11 @@ class Router {
    *
    * const app = new AppSyncGraphQLResolver();
    *
-   * app.onMutation<{ title: string; content: string }>('createPost', async ({ title, content }) => {
-   *   // title and content are now typed as string
-   *   return { id: '123', title, content };
+   * app.resolver<{ postId: string }>(async ({ postId }) => {
+   *   // postId is now typed as string
+   *   return { id: postId };
+   * }, {
+   *   fieldName: 'getPost'
    * });
    *
    * export const handler = async (event, context) =>
@@ -209,8 +109,8 @@ class Router {
    * const app = new AppSyncGraphQLResolver();
    *
    * class Lambda {
-   *   @app.onMutation('createPost')
-   *   async handleCreatePost(payload) {
+   *   @app.resolver({ fieldName: 'getPost' })
+   *   async handleGetPost(payload) {
    *     // your business logic here
    *     return payload;
    *   }
@@ -224,41 +124,43 @@ class Router {
    * export const handler = lambda.handler.bind(lambda);
    * ```
    *
-   * @param fieldName - The name of the Mutation field to register the handler for.
    * @param handler - The handler function to be called when the event is received.
-   * @param options - Optional route options.
-   * @param options.typeName - The name of the GraphQL type to use for the resolver (defaults to 'Mutation').
+   * @param options - Route options including the required fieldName and optional typeName.
+   * @param options.fieldName - The name of the field to register the handler for.
+   * @param options.typeName - The name of the GraphQL type to use for the resolver (defaults to 'Query').
    */
-  public onMutation<TParams extends Record<string, unknown>>(
-    fieldName: string,
-    handler: OnMutationHandler<TParams>,
-    options?: GraphQlRouteOptions
+  public resolver<TParams extends Record<string, unknown>>(
+    handler: ResolverHandler<TParams>,
+    options: GraphQlRouteOptions
   ): void;
-  public onMutation(
-    fieldName: string,
-    options?: GraphQlRouteOptions
-  ): MethodDecorator;
-  public onMutation<TParams extends Record<string, unknown>>(
-    fieldName: string,
-    handler?: OnMutationHandler<TParams> | GraphQlRouteOptions,
+  public resolver(options: GraphQlRouteOptions): MethodDecorator;
+  public resolver<TParams extends Record<string, unknown>>(
+    handler: ResolverHandler<TParams> | GraphQlRouteOptions,
     options?: GraphQlRouteOptions
   ): MethodDecorator | undefined {
-    if (handler && typeof handler === 'function') {
-      this.onMutationRegistry.register({
-        fieldName,
-        handler: handler as OnMutationHandler<Record<string, unknown>>,
-        typeName: options?.typeName ?? 'Mutation',
+    if (typeof handler === 'function') {
+      const resolverOptions = options as GraphQlRouteOptions;
+      const typeName = resolverOptions.typeName ?? 'Query';
+
+      this.resolverRegistry.register({
+        fieldName: resolverOptions.fieldName,
+        handler: handler as ResolverHandler<Record<string, unknown>>,
+        typeName,
       });
+
       return;
     }
 
+    const resolverOptions = handler;
     return (_target, _propertyKey, descriptor: PropertyDescriptor) => {
-      const routeOptions = isRecord(handler) ? handler : options;
-      this.onMutationRegistry.register({
-        fieldName,
-        handler: descriptor.value as OnMutationHandler<Record<string, unknown>>,
-        typeName: routeOptions?.typeName ?? 'Mutation',
+      const typeName = resolverOptions.typeName ?? 'Query';
+
+      this.resolverRegistry.register({
+        fieldName: resolverOptions.fieldName,
+        handler: descriptor.value,
+        typeName,
       });
+
       return descriptor;
     };
   }