feat: custom response templates

Author: rschick

README.md

@@ -627,3 +627,36 @@ custom:
 > It is important that the mapping template will return a valid `application/x-www-form-urlencoded` string
 
 Source: [Connect AWS API Gateway directly to SNS using a service integration](https://www.alexdebrie.com/posts/aws-api-gateway-service-proxy/)
+
+### Custom response body mapping templates
+
+You can customize the response body by providing mapping templates for success, server errors (5xx) and client errors (4xx).
+
+> Templates must be in JSON format. If a template isn't provided, the integration response will be returned as-is to the client.
+
+#### Kinesis Example
+
+```yml
+custom:
+  apiGatewayServiceProxies:
+    - kinesis:
+        path: /kinesis
+        method: post
+        streamName: { Ref: 'MyStream' }
+        response:
+          template:
+            success: |
+              {
+                "success": true
+              }
+            serverError: |
+              {
+                "success": false,
+                "errorMessage": "Server Error"
+              }
+            clientError: |
+              {
+                "success": false,
+                "errorMessage": "Client Error"
+              }
+```

lib/apiGateway/schema.js

@@ -167,11 +167,19 @@ const request = Joi.object({
   template: Joi.object().required()
 })
 
+const response = Joi.object({
+  template: Joi.object().keys({
+    success: Joi.string(),
+    clientError: Joi.string(),
+    serverError: Joi.string()
+  })
+})
+
 const allowedProxies = ['kinesis', 'sqs', 's3', 'sns', 'dynamodb']
 
 const proxiesSchemas = {
   kinesis: Joi.object({
-    kinesis: proxy.append({ streamName: stringOrRef.required(), partitionKey, request })
+    kinesis: proxy.append({ streamName: stringOrRef.required(), partitionKey, request, response })
   }),
   s3: Joi.object({
     s3: proxy.append({

lib/package/kinesis/compileMethodsToKinesis.js

@@ -65,19 +65,19 @@ module.exports = {
           StatusCode: 200,
           SelectionPattern: 200,
           ResponseParameters: {},
-          ResponseTemplates: {}
+          ResponseTemplates: this.getKinesisIntegrationResponseTemplate(http, 'success')
         },
         {
           StatusCode: 400,
           SelectionPattern: 400,
           ResponseParameters: {},
-          ResponseTemplates: {}
+          ResponseTemplates: this.getKinesisIntegrationResponseTemplate(http, 'clientError')
         },
         {
           StatusCode: 500,
           SelectionPattern: 500,
           ResponseParameters: {},
-          ResponseTemplates: {}
+          ResponseTemplates: this.getKinesisIntegrationResponseTemplate(http, 'serverError')
         }
       ]
     }
@@ -98,6 +98,11 @@ module.exports = {
     return Object.assign(defaultRequestTemplates, _.get(http, ['request', 'template']))
   },
 
+  getKinesisIntegrationResponseTemplate(http, statusType) {
+    const template = _.get(http, ['response', 'template', statusType])
+    return Object.assign({}, template && { 'application/json': template })
+  },
+
   getDefaultKinesisRequestTemplates(http) {
     return {
       'application/json': this.buildDefaultKinesisRequestTemplate(http),

lib/package/kinesis/compileMethodsToKinesis.test.js

@@ -532,7 +532,7 @@ describe('#compileMethodsToKinesis()', () => {
     ])
   })
 
-  it('should return a custom template for application/json when one is given', () => {
+  it('should return a custom request template for application/json when one is given', () => {
     const httpWithRequestTemplate = {
       path: 'foo/bar1',
       method: 'post',
@@ -553,6 +553,35 @@ describe('#compileMethodsToKinesis()', () => {
     )
   })
 
+  it('should return a custom response template for application/json when one is given', () => {
+    const httpWithRequestTemplate = {
+      path: 'foo/bar1',
+      method: 'post',
+      response: {
+        template: {
+          success: 'success template',
+          clientError: 'client error template',
+          serverError: 'server error template'
+        }
+      },
+      auth: {
+        authorizationType: 'NONE'
+      }
+    }
+    const resource = serverlessApigatewayServiceProxy.getKinesisMethodIntegration(
+      httpWithRequestTemplate
+    )
+    expect(
+      resource.Properties.Integration.IntegrationResponses[0].ResponseTemplates['application/json']
+    ).to.be.equal('success template')
+    expect(
+      resource.Properties.Integration.IntegrationResponses[1].ResponseTemplates['application/json']
+    ).to.be.equal('client error template')
+    expect(
+      resource.Properties.Integration.IntegrationResponses[2].ResponseTemplates['application/json']
+    ).to.be.equal('server error template')
+  })
+
   it('should return the default for application/x-www-form-urlencoded when one is not given', () => {
     const httpWithoutRequestTemplate = {
       streamName: 'myStream',