feat(data-classes): Include include_event and include_context

Author: Michael Brewer

aws_lambda_powertools/utilities/data_classes/appsync_resolver_utils.py

@@ -42,7 +42,14 @@ class AppSyncResolver:
     def __init__(self):
         self._resolvers: dict = {}
 
-    def resolver(self, type_name: str = "*", field_name: str = None, **kwargs):
+    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
@@ -51,11 +58,17 @@ def resolver(self, type_name: str = "*", field_name: str = None, **kwargs):
             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 :
-            Keyword arguments
+            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,

tests/functional/appsync/test_appsync_resolver_utils.py

@@ -13,6 +13,7 @@
     aws_timestamp,
     make_id,
 )
+from aws_lambda_powertools.utilities.typing import LambdaContext
 
 
 def load_event(file_name: str) -> dict:
@@ -22,7 +23,8 @@ def load_event(file_name: str) -> dict:
 
 
 def test_direct_resolver():
-    _event = load_event("appSyncDirectResolver.json")
+    # Check whether we can handle an example appsync direct resolver
+    mock_event = load_event("appSyncDirectResolver.json")
 
     app = AppSyncResolver()
 
@@ -34,12 +36,13 @@ def create_something(context, id: str):  # noqa AA03 VNE003
     def handler(event, context):
         return app.resolve(event, context)
 
-    result = handler(_event, {})
+    result = handler(mock_event, {})
     assert result == "my identifier"
 
 
 def test_amplify_resolver():
-    _event = load_event("appSyncResolverEvent.json")
+    # Check whether we can handle an example appsync resolver
+    mock_event = load_event("appSyncResolverEvent.json")
 
     app = AppSyncResolver()
 
@@ -53,30 +56,73 @@ def get_location(event: AppSyncResolverEvent, page: int, size: int, name: str):
     def handler(event, context):
         return app.resolve(event, context)
 
-    result = handler(_event, {})
+    result = handler(mock_event, {})
     assert result == "value"
 
 
 def test_resolver_no_params():
+    # GIVEN
     app = AppSyncResolver()
 
     @app.resolver(type_name="Query", field_name="noParams")
     def no_params():
         return "no_params has no params"
 
     event = {"typeName": "Query", "fieldName": "noParams", "arguments": {}}
-    result = app.resolve(event, None)
 
+    # WHEN
+    result = app.resolve(event, LambdaContext())
+
+    # THEN
     assert result == "no_params has no params"
 
 
+def test_resolver_include_event():
+    # GIVEN
+    app = AppSyncResolver()
+
+    mock_event = {"typeName": "Query", "fieldName": "field", "arguments": {}}
+
+    @app.resolver(field_name="field", include_event=True)
+    def get_value(event: AppSyncResolverEvent):
+        return event
+
+    # WHEN
+    result = app.resolve(mock_event, LambdaContext())
+
+    # THEN
+    assert result._data == mock_event
+    assert isinstance(result, AppSyncResolverEvent)
+
+
+def test_resolver_include_context():
+    # GIVEN
+    app = AppSyncResolver()
+
+    mock_event = {"typeName": "Query", "fieldName": "field", "arguments": {}}
+
+    @app.resolver(field_name="field", include_context=True)
+    def get_value(context: LambdaContext):
+        return context
+
+    # WHEN
+    mock_context = LambdaContext()
+    result = app.resolve(mock_event, mock_context)
+
+    # THEN
+    assert result == mock_context
+
+
 def test_resolver_value_error():
+    # GIVEN no defined field resolver
     app = AppSyncResolver()
 
+    # WHEN
     with pytest.raises(ValueError) as exp:
         event = {"typeName": "type", "fieldName": "field", "arguments": {}}
-        app.resolve(event, None)
+        app.resolve(event, LambdaContext())
 
+    # THEN
     assert exp.value.args[0] == "No resolver found for 'type.field'"