Feature Request: API Gateway Direct Resolvers (AppSync-style without VTL)

[aleguern-azivko]

Feature Request: API Gateway JavaScript Resolvers (AppSync-style JS)

Description

This PR proposes adding AppSync-style JavaScript resolvers to SAM for API Gateway, allowing direct integration with AWS services without the need for Lambda functions or VTL templates.

Problem Statement

Currently, connecting API Gateway to AWS services like DynamoDB requires:

1. Writing Lambda functions as "glue code"
2. Handling error cases, status codes, and response formatting in code
3. Managing additional Lambda configuration and permissions
4. Writing unnecessary boilerplate for simple CRUD operations

Example of unnecessary Lambda boilerplate:

const getProduct = async (event: APIGatewayProxyEvent) => {
  try {
    const { id } = event.pathParameters

    const response = await docClient.send(
      new GetCommand({
        TableName: TABLE_NAME,
        Key: { id },
      }),
    );

    if (!response.Item) {
      return {
        statusCode: 404,
        headers: corsHeaders,
        body: JSON.stringify({ error: 'item_not_found' }),
      };
    }

    return {
      statusCode: 200,
      headers: corsHeaders,
      body: JSON.stringify(response.Item),
    };
  } catch (error) {
    console.error('Error:', error);
    return {
      statusCode: 500,
      headers: corsHeaders,
      body: JSON.stringify({ error: 'Internal Server Error' }),
    };
  }
};

Proposed Solution

Add AppSync-style JavaScript resolvers to SAM for API Gateway, allowing templates like:

AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31
Resources:
  GetProductResolver:
    Type: AWS::Serverless::Resolver
    Properties:
      Path: /products/{row}/{id}
      Method: GET
      DataSource:
        Type: AMAZON_DYNAMODB
        Config:
          TableName: !Ref ProductsTable
          ServiceRoleArn: !GetAtt DynamoDBResolverRole.Arn
      Runtime: APPSYNC_JS
      Code: |
        export function request(ctx) {
          return {
            operation: "GetItem",
            key: {
              row: ctx.args.row,
              id: ctx.args.id
            }
          };
        }
        
        export function response(ctx) {
          if (ctx.error) {
            util.error(ctx.error.message);
          }
          
          if (!ctx.result) {
            ctx.responseOverride = { statusCode: 404 };
            return { error: "item_not_found" };
          }
          
          return ctx.result;
        }

  DynamoDBResolverRole:
    Type: AWS::IAM::Role
    Properties:
      AssumeRolePolicyDocument:
        Version: '2012-10-17'
        Statement:
          - Effect: Allow
            Principal:
              Service: apigateway.amazonaws.com
            Action: sts:AssumeRole
      ManagedPolicyArns:
        - arn:aws:iam::aws:policy/AmazonDynamoDBReadOnlyAccess

Implementation Details

The implementation would closely mirror AppSync's JavaScript resolver pattern:

1. Runtime: Support for JavaScript (APPSYNC_JS) runtime to align with AppSync's model

2. Data Sources: Support for direct connections to:

   • DynamoDB
   • RDS Data API
   • OpenSearch
   • EventBridge
   • Step Functions
   • HTTP endpoints

3. JavaScript Functions:

   • Two primary functions: request and response
   • Clean, modern JavaScript syntax with async/await support
   • Full access to the resolver context and utilities

4. Built-in Utility Library:

   // Available in JavaScript resolvers
   util.autoId()
   util.unauthorized()
   util.error()
   util.appendError()
   util.validate()
   util.isNull()
   util.isNullOrEmpty()
   util.isNullOrBlank()
   util.isString()
   util.matches()
   util.authType()
   util.quiet()
   util.qr()
   util.escapeJavaScript()

5. Context Object:
   Provide rich context similar to AppSync's JavaScript resolvers:

   ctx.arguments        // arguments/parameters
   ctx.args             // shorthand for ctx.arguments
   ctx.identity         // requestor identity 
   ctx.source           // source data
   ctx.result           // service response
   ctx.info             // resolver info
   ctx.prev.result      // previous operation result
   ctx.stash            // place to store values
   ctx.responseOverride // manipulate response

6. Response Handling:

   • Status code setting via ctx.responseOverride.statusCode
   • Header manipulation
   • Error handling with util.error() and util.appendError()
   • Full JavaScript control flow for complex conditionals

Benefits

1. Modern JavaScript syntax: No need to learn VTL, use familiar JavaScript
2. Elimination of Lambda glue code: Direct connection to AWS services
3. Reduced costs: No Lambda invocation charges for simple operations
4. Simplified architecture: Fewer moving parts and points of failure
5. Consistency with AppSync: Leverage existing AppSync JS resolver knowledge
6. Enhanced developer productivity: Less boilerplate and familiar language
7. Better security: Fine-grained IAM permissions at the resolver level
8. Improved performance: Eliminates Lambda cold starts for simple operations
9. Better debugging: JavaScript error handling and logging
10. Enhanced testability: JavaScript resolvers can be tested more easily

I believe this feature would significantly improve the developer experience for SAM users by eliminating unnecessary Lambda functions for common data access patterns while providing the flexibility and power of JavaScript.