Building AWS AppSync Pipeline Resolvers with AWS CloudFormation

3 min readMar 11, 2019

Among the many updates from AWS AppSync over the past few months, the addition of Pipeline Resolvers was particularly exciting. Pipeline Resolvers allow us to build a resolver from a series of reusable functions, each of which can query a separate data source. This approach can be useful in performing an authorization check or resolving a batch request across data sources.

For example, I recently built a Pipeline Resolver composed of two functions:

Retrieves a list of recent items, each identified by a unique ID, from Amazon ElastiCache via a AWS Lambda data source.
Retrieves each of the items from an Amazon DynamoDB data source using BatchGetItem.

Using a Pipeline Resolver allowed for separation of functionality as well as composition via AppSync.

Instead of reviewing how I built the resolver, in this post, I will share how I built it using AWS CloudFormation. If you are interested in an overview of Pipeline Resolvers or an example implementation, see the Resources section below.

Building a Pipeline Resolver with CloudFormation

When building a Pipeline Resolver in CloudFormation, we specify a resolver as well as the functions that compose that resolver. The resolver and its composite functions will contain request and response mapping templates, but only the functions will have a data source. To demonstrate, we will implement theListPosts resolver found in Nader Dabit’s Intro to AWS AppSync Pipeline Functions:

First, we’ll implement the resolver. We’ll assume the AppSync API and other applicable resources have already been created:

ListPostsQueryResolver:
  Type: AWS::AppSync::Resolver
  DependsOn: MySchema
  Properties:
    ApiId: !GetAtt MyApi.ApiId
    TypeName: Query
    FieldName: listPosts
    # configure this resolver as a pipeline
    Kind: PIPELINE
    PipelineConfig:
      Functions:
        - !GetAtt IsUserCallerFunction.FunctionId
        - !GetAtt GetPostsFunction.FunctionId
    # see Nader's article for details on these templates
    RequestMappingTemplate: |
      $util.qr($ctx.stash.put("callerId", $ctx.identity.sub))
      $util.qr($ctx.stash.put("userId", $ctx.args.userId))
      {}
    ResponseMappingTemplate: |
      $util.toJson($ctx.result)

Next, we will implement the first of two pipeline functions:

IsUserCallerFunction:
  Type: AWS::AppSync::FunctionConfiguration
  Properties:
    ApiId: !GetAtt MyApi.ApiId
    Name: is_user_caller
    Description: Checks to see if the user is also the caller
    DataSourceName: !GetAtt UsersDynamoDBDataSource.Name
    FunctionVersion: "2018-05-29"
    RequestMappingTemplate: |
      #if($ctx.stash.callerId == $ctx.stash.userId)
        #return($ctx.prev.result)
      #else
        {
          "operation": "GetItem",
          "key": {
            "id": $util.dynamodb.toDynamoDBJson($ctx.stash.callerId),
          }
        }
      #end
    ResponseMappingTemplate: |
      #if($ctx.result.level != "admin")
        $util.error("User is not authorized to make this query")
      #else
        $util.toJson($ctx.result)
      #end

Finally, we’ll add the second function:

GetPostsFunction:
  Type: AWS::AppSync::FunctionConfiguration
  Properties:
    ApiId: !GetAtt MyApi.ApiId
    Name: get_posts
    Description: Scan table and retrieve items created by user
    DataSourceName: !GetAtt PostsDynamoDBDataSource.Name
    FunctionVersion: "2018-05-29"
    RequestMappingTemplate: |
      {
        "operation" : "Scan",
        "filter" : {
          "expression" : "#userId = :userId",
          "expressionNames" : {
              "#userId" : "userId"
          },
          "expressionValues" : {
             ":userId" : $util.dynamodb.toDynamoDBJson($ctx.stash.userId)
          }
        },
        "nextToken": $util.toJson($util.defaultIfNullOrBlank($ctx.args.nextToken, null))
      }
    ResponseMappingTemplate: |
      #if($ctx.error)
        $util.error($ctx.error.message, $ctx.error.type)
      #end
      {
        "items": $util.toJson($ctx.result.items),
        "nextToken": $util.toJson($util.defaultIfNullOrBlank($context.result.nextToken, null))
      }

After creating the CloudFormation stack, we can test the resolver via the AppSync Console. As usual, CloudFormation brings the value of reuse, portability, configurability.

Thanks for reading and please feel free to leave a comment with any questions.

Building AWS AppSync Pipeline Resolvers with AWS CloudFormation

Building a Pipeline Resolver with CloudFormation

Resources

Written by Josh Kahn