feat(event-handler): Add AppSync handler decorator

Author: michaelbrewer

aws_lambda_powertools/utilities/data_classes/__init__.py

@@ -1,7 +1,6 @@
-from aws_lambda_powertools.utilities.data_classes.appsync_resolver_event import AppSyncResolverEvent
-
 from .alb_event import ALBEvent
 from .api_gateway_proxy_event import APIGatewayProxyEvent, APIGatewayProxyEventV2
+from .appsync_resolver_event import AppSyncResolverEvent
 from .cloud_watch_logs_event import CloudWatchLogsEvent
 from .connect_contact_flow_event import ConnectContactFlowEvent
 from .dynamo_db_stream_event import DynamoDBStreamEvent

aws_lambda_powertools/utilities/data_classes/appsync/resolver_utils.py

@@ -0,0 +1,3 @@
+from .appsync import AppSyncResolver
+
+__all__ = ["AppSyncResolver"]

aws_lambda_powertools/utilities/event_handler/__init__.py

@@ -0,0 +1,146 @@
+from typing import Any, Dict
+
+from aws_lambda_powertools.utilities.data_classes import AppSyncResolverEvent
+from aws_lambda_powertools.utilities.typing import LambdaContext
+
+
+class AppSyncResolver:
+    """
+    AppSync resolver decorator
+
+    Example
+    -------
+
+    **Sample usage**
+
+        from aws_lambda_powertools.utilities.data_classes import AppSyncResolverEvent
+        from aws_lambda_powertools.utilities.event_handler import AppSyncResolver
+
+        app = AppSyncResolver()
+
+        @app.resolver(type_name="Query", field_name="listLocations", include_event=True)
+        def list_locations(event: AppSyncResolverEvent, page: int = 0, size: int = 10):
+            # Your logic to fetch locations
+            ...
+
+        @app.resolver(type_name="Merchant", field_name="extraInfo", include_event=True)
+        def get_extra_info(event: AppSyncResolverEvent):
+            # Can use "event.source" to filter within the parent context
+            ...
+
+        @app.resolver(field_name="commonField")
+        def common_field():
+            # Would match all fieldNames matching 'commonField'
+            ...
+
+        def handle(event, context):
+            app.resolve(event, context)
+
+    """
+
+    def __init__(self):
+        self._resolvers: dict = {}
+
+    def resolver(
+        self,
+        type_name: str = "*",
+        field_name: str = None,
+        include_event: bool = False,
+        include_context: bool = False,
+        **kwargs,
+    ):
+        """Registers the resolver for field_name
+
+        Parameters
+        ----------
+        type_name : str
+            Type name
+        field_name : str
+            Field name
+        include_event: bool
+            Whether to include the lambda event
+        include_context: bool
+            Whether to include the lambda context
+        kwargs :
+            Extra options via kwargs
+        """
+
+        def register_resolver(func):
+            kwargs["include_event"] = include_event
+            kwargs["include_context"] = include_context
+            self._resolvers[f"{type_name}.{field_name}"] = {
+                "func": func,
+                "config": kwargs,
+            }
+            return func
+
+        return register_resolver
+
+    def resolve(self, _event: dict, context: LambdaContext) -> Any:
+        """Resolve field_name
+
+        Parameters
+        ----------
+        _event : dict
+            Lambda event
+        context : LambdaContext
+            Lambda context
+
+        Returns
+        -------
+        Any
+            Returns the result of the resolver
+
+        Raises
+        -------
+        ValueError
+            If we could not find a field resolver
+        """
+        event = AppSyncResolverEvent(_event)
+        resolver, config = self._resolver(event.type_name, event.field_name)
+        kwargs = self._kwargs(event, context, config)
+        return resolver(**kwargs)
+
+    def _resolver(self, type_name: str, field_name: str) -> tuple:
+        """Find resolver for field_name
+
+        Parameters
+        ----------
+        type_name : str
+            Type name
+        field_name : str
+            Field name
+
+        Returns
+        -------
+        tuple
+            callable function and configuration
+        """
+        full_name = f"{type_name}.{field_name}"
+        resolver = self._resolvers.get(full_name, self._resolvers.get(f"*.{field_name}"))
+        if not resolver:
+            raise ValueError(f"No resolver found for '{full_name}'")
+        return resolver["func"], resolver["config"]
+
+    @staticmethod
+    def _kwargs(event: AppSyncResolverEvent, context: LambdaContext, config: dict) -> Dict[str, Any]:
+        """Get the keyword arguments
+        Parameters
+        ----------
+        event : AppSyncResolverEvent
+            Lambda event
+        context : LambdaContext
+            Lambda context
+        config : dict
+            Configuration settings
+        Returns
+        -------
+        dict
+            Returns keyword arguments
+        """
+        kwargs = {**event.arguments}
+        if config.get("include_event", False):
+            kwargs["event"] = event
+        if config.get("include_context", False):
+            kwargs["context"] = context
+        return kwargs

aws_lambda_powertools/utilities/event_handler/appsync.py

@@ -3,8 +3,7 @@ title: Event Source Data Classes
 description: Utility
 ---
 
-Event Source Data Classes utility provides classes self-describing Lambda event sources, including API decorators when
-applicable.
+Event Source Data Classes utility provides classes self-describing Lambda event sources.
 
 ## Key Features
 

docs/utilities/data_classes.md

@@ -1,21 +1,12 @@
 import asyncio
-import datetime
 import json
 import os
 import sys
 
 import pytest
 
 from aws_lambda_powertools.utilities.data_classes import AppSyncResolverEvent
-from aws_lambda_powertools.utilities.data_classes.appsync.resolver_utils import AppSyncResolver
-from aws_lambda_powertools.utilities.data_classes.appsync.scalar_types_utils import (
-    _formatted_time,
-    aws_date,
-    aws_datetime,
-    aws_time,
-    aws_timestamp,
-    make_id,
-)
+from aws_lambda_powertools.utilities.event_handler import AppSyncResolver
 from aws_lambda_powertools.utilities.typing import LambdaContext
 
 
@@ -189,46 +180,3 @@ async def get_async():
 
     # THEN
     assert asyncio.run(result) == "value"
-
-
-def test_make_id():
-    uuid: str = make_id()
-    assert isinstance(uuid, str)
-    assert len(uuid) == 36
-
-
-def test_aws_date_utc():
-    date_str = aws_date()
-    assert isinstance(date_str, str)
-    assert datetime.datetime.strptime(date_str, "%Y-%m-%dZ")
-
-
-def test_aws_time_utc():
-    time_str = aws_time()
-    assert isinstance(time_str, str)
-    assert datetime.datetime.strptime(time_str, "%H:%M:%SZ")
-
-
-def test_aws_datetime_utc():
-    datetime_str = aws_datetime()
-    assert isinstance(datetime_str, str)
-    assert datetime.datetime.strptime(datetime_str, "%Y-%m-%dT%H:%M:%SZ")
-
-
-def test_aws_timestamp():
-    timestamp = aws_timestamp()
-    assert isinstance(timestamp, int)
-
-
-def test_format_time_positive():
-    now = datetime.datetime(2022, 1, 22)
-    datetime_str = _formatted_time(now, "%Y-%m-%d", 8)
-    assert isinstance(datetime_str, str)
-    assert datetime_str == "2022-01-22+08:00:00"
-
-
-def test_format_time_negative():
-    now = datetime.datetime(2022, 1, 22, 14, 22, 33)
-    datetime_str = _formatted_time(now, "%H:%M:%S", -12)
-    assert isinstance(datetime_str, str)
-    assert datetime_str == "02:22:33-12:00:00"

tests/functional/event_handler/__init__.py

@@ -1,4 +1,5 @@
 import base64
+import datetime
 import json
 import os
 from secrets import compare_digest
@@ -17,6 +18,14 @@
     SNSEvent,
     SQSEvent,
 )
+from aws_lambda_powertools.utilities.data_classes.appsync.scalar_types_utils import (
+    _formatted_time,
+    aws_date,
+    aws_datetime,
+    aws_time,
+    aws_timestamp,
+    make_id,
+)
 from aws_lambda_powertools.utilities.data_classes.appsync_resolver_event import (
     AppSyncIdentityCognito,
     AppSyncIdentityIAM,
@@ -1059,3 +1068,46 @@ def test_s3_object_event_temp_credentials():
     assert session_attributes is not None
     assert session_attributes.mfa_authenticated == session_context["attributes"]["mfaAuthenticated"]
     assert session_attributes.creation_date == session_context["attributes"]["creationDate"]
+
+
+def test_make_id():
+    uuid: str = make_id()
+    assert isinstance(uuid, str)
+    assert len(uuid) == 36
+
+
+def test_aws_date_utc():
+    date_str = aws_date()
+    assert isinstance(date_str, str)
+    assert datetime.datetime.strptime(date_str, "%Y-%m-%dZ")
+
+
+def test_aws_time_utc():
+    time_str = aws_time()
+    assert isinstance(time_str, str)
+    assert datetime.datetime.strptime(time_str, "%H:%M:%SZ")
+
+
+def test_aws_datetime_utc():
+    datetime_str = aws_datetime()
+    assert isinstance(datetime_str, str)
+    assert datetime.datetime.strptime(datetime_str, "%Y-%m-%dT%H:%M:%SZ")
+
+
+def test_aws_timestamp():
+    timestamp = aws_timestamp()
+    assert isinstance(timestamp, int)
+
+
+def test_format_time_positive():
+    now = datetime.datetime(2022, 1, 22)
+    datetime_str = _formatted_time(now, "%Y-%m-%d", 8)
+    assert isinstance(datetime_str, str)
+    assert datetime_str == "2022-01-22+08:00:00"
+
+
+def test_format_time_negative():
+    now = datetime.datetime(2022, 1, 22, 14, 22, 33)
+    datetime_str = _formatted_time(now, "%H:%M:%S", -12)
+    assert isinstance(datetime_str, str)
+    assert datetime_str == "02:22:33-12:00:00"