feat: allow passing additional request parameters for sqs

Author: erezrokah

README.md

@@ -214,3 +214,27 @@ custom:
 ```
 
 Source: [How to connect SNS to Kinesis for cross-account delivery via API Gateway](https://theburningmonk.com/2019/07/how-to-connect-sns-to-kinesis-for-cross-account-delivery-via-api-gateway/)
+
+### SQS
+
+#### Customizing request parameters
+
+If you'd like to pass additional data to the integration request, you can do so by including your custom [API Gateway request parameters](https://docs.aws.amazon.com/apigateway/latest/developerguide/request-response-data-mappings.html) in `serverless.yml` like so:
+
+```yml
+custom:
+  apiGatewayServiceProxies:
+    - sqs:
+        path: /queue
+        method: post
+        queueName: !GetAtt MyQueue.QueueName
+        cors: true
+
+        requestParameters:
+          'integration.request.querystring.MessageAttribute.1.Name': "'cognitoIdentityId'"
+          'integration.request.querystring.MessageAttribute.1.Value.StringValue': 'context.identity.cognitoIdentityId'
+          'integration.request.querystring.MessageAttribute.1.Value.DataType': "'String'"
+          'integration.request.querystring.MessageAttribute.2.Name': "'cognitoAuthenticationProvider'"
+          'integration.request.querystring.MessageAttribute.2.Value.StringValue': 'context.identity.cognitoAuthenticationProvider'
+          'integration.request.querystring.Me]
+```

lib/apiGateway/validate.js

@@ -16,6 +16,8 @@ module.exports = {
         http.method = await this.getProxyMethod(serviceProxy[serviceName], serviceName)
         http.auth = await this.getAuth(serviceProxy[serviceName], serviceName)
 
+        await this.validateRequestParameters(serviceProxy[serviceName], serviceName)
+
         if (serviceProxy[serviceName].cors) {
           http.cors = await this.getCors(serviceProxy[serviceName])
 
@@ -210,5 +212,28 @@ module.exports = {
     }
 
     return auth
+  },
+
+  async validateRequestParameters(proxy, serviceName) {
+    if (!_.isUndefined(proxy.requestParameters)) {
+      if (serviceName !== 'sqs') {
+        return BbPromise.reject(
+          new this.serverless.classes.Error(
+            'requestParameters property is only valid for "sqs" service proxy'
+          )
+        )
+      }
+
+      if (
+        !_.isPlainObject(proxy.requestParameters) ||
+        _.some(_.values(proxy.requestParameters), (v) => !_.isString(v))
+      ) {
+        return BbPromise.reject(
+          new this.serverless.classes.Error(
+            'requestParameters property must be a string to string mapping'
+          )
+        )
+      }
+    }
   }
 }

lib/apiGateway/validate.test.js

@@ -532,4 +532,56 @@ describe('#validateServiceProxies()', () => {
       }
     )
   })
+
+  it('should validate requestParameters only used for sqs', async () => {
+    serverlessApigatewayServiceProxy.serverless.service.custom = {
+      apiGatewayServiceProxies: [
+        {
+          kinesis: {
+            path: '/kinesis',
+            method: 'post',
+            requestParameters: { key: 'value' }
+          }
+        }
+      ]
+    }
+
+    await expect(serverlessApigatewayServiceProxy.validateServiceProxies()).to.be.rejectedWith(
+      'requestParameters property is only valid for "sqs" service proxy'
+    )
+  })
+
+  it('should validate requestParameters is a string to string mapping', async () => {
+    serverlessApigatewayServiceProxy.serverless.service.custom = {
+      apiGatewayServiceProxies: [
+        {
+          sqs: {
+            path: '/sqs',
+            method: 'post',
+            requestParameters: { key1: 'value', key2: [] }
+          }
+        }
+      ]
+    }
+
+    await expect(serverlessApigatewayServiceProxy.validateServiceProxies()).to.be.rejectedWith(
+      'requestParameters property must be a string to string mapping'
+    )
+  })
+
+  it('should allow valid requestParameters property', async () => {
+    serverlessApigatewayServiceProxy.serverless.service.custom = {
+      apiGatewayServiceProxies: [
+        {
+          sqs: {
+            path: '/sqs',
+            method: 'post',
+            requestParameters: { key1: 'value', key2: 'value2' }
+          }
+        }
+      ]
+    }
+
+    await expect(serverlessApigatewayServiceProxy.validateServiceProxies()).to.be.fulfilled
+  })
 })

lib/package/sqs/compileMethodsToSqs.js

@@ -74,10 +74,13 @@ module.exports = {
           ]
         ]
       },
-      RequestParameters: {
-        'integration.request.querystring.Action': "'SendMessage'",
-        'integration.request.querystring.MessageBody': 'method.request.body'
-      },
+      RequestParameters: _.merge(
+        {
+          'integration.request.querystring.Action': "'SendMessage'",
+          'integration.request.querystring.MessageBody': 'method.request.body'
+        },
+        http.requestParameters
+      ),
       RequestTemplates: { 'application/json': '{statusCode:200}' }
     }
 

lib/package/sqs/compileMethodsToSqs.test.js

@@ -380,4 +380,90 @@ describe('#compileIamRoleToSqs()', () => {
       }
     })
   })
+
+  it('should add additional requestParameters', async () => {
+    serverlessApigatewayServiceProxy.validated = {
+      events: [
+        {
+          serviceName: 'sqs',
+          http: {
+            queueName: 'myQueue',
+            path: 'sqs',
+            method: 'post',
+            auth: {
+              authorizationType: 'NONE'
+            },
+            requestParameters: { key1: 'value1', key2: 'value2' }
+          }
+        }
+      ]
+    }
+    serverlessApigatewayServiceProxy.apiGatewayRestApiLogicalId = 'ApiGatewayRestApi'
+    serverlessApigatewayServiceProxy.apiGatewayResources = {
+      sqs: {
+        name: 'sqs',
+        resourceLogicalId: 'ApiGatewayResourceSqs'
+      }
+    }
+
+    await expect(serverlessApigatewayServiceProxy.compileMethodsToSqs()).to.be.fulfilled
+    expect(serverless.service.provider.compiledCloudFormationTemplate.Resources).to.deep.equal({
+      ApiGatewayMethodsqsPost: {
+        Type: 'AWS::ApiGateway::Method',
+        Properties: {
+          HttpMethod: 'POST',
+          RequestParameters: {},
+          AuthorizationType: 'NONE',
+          AuthorizationScopes: undefined,
+          AuthorizerId: undefined,
+          ApiKeyRequired: false,
+          ResourceId: { Ref: 'ApiGatewayResourceSqs' },
+          RestApiId: { Ref: 'ApiGatewayRestApi' },
+          Integration: {
+            IntegrationHttpMethod: 'POST',
+            Type: 'AWS',
+            Credentials: { 'Fn::GetAtt': ['ApigatewayToSqsRole', 'Arn'] },
+            Uri: {
+              'Fn::Join': [
+                '',
+                [
+                  'arn:aws:apigateway:',
+                  { Ref: 'AWS::Region' },
+                  ':sqs:path//',
+                  { Ref: 'AWS::AccountId' },
+                  '/',
+                  '"myQueue"'
+                ]
+              ]
+            },
+            RequestParameters: {
+              'integration.request.querystring.Action': "'SendMessage'",
+              'integration.request.querystring.MessageBody': 'method.request.body',
+              key1: 'value1',
+              key2: 'value2'
+            },
+            RequestTemplates: { 'application/json': '{statusCode:200}' },
+            IntegrationResponses: [
+              {
+                StatusCode: 200,
+                SelectionPattern: 200,
+                ResponseParameters: {},
+                ResponseTemplates: {}
+              },
+              {
+                StatusCode: 400,
+                SelectionPattern: 400,
+                ResponseParameters: {},
+                ResponseTemplates: {}
+              }
+            ]
+          },
+          MethodResponses: [
+            { ResponseParameters: {}, ResponseModels: {}, StatusCode: 200 },
+            { ResponseParameters: {}, ResponseModels: {}, StatusCode: 400 }
+          ]
+        }
+      }
+    })
+  })
 })