Support for Cloudwatch Event InputTransformer

docs/providers/aws/events/cloudwatch-event.md

@@ -89,6 +89,19 @@ functions:
               state:
                 - pending
           inputPath: '$.stageVariables'
+      - cloudwatchEvent:
+          event:
+            source:
+              - "aws.ec2"
+            detail-type:
+              - "EC2 Instance State-change Notification"
+            detail:
+              state:
+                - pending
+          inputTransformer:
+            inputPathsMap:
+              eventTime: '$.time'
+            inputTemplate: '{"time": <eventTime>, "key1": "value1"}'
 ```
 
 ## Specifying a Description

docs/providers/aws/events/schedule.md

@@ -47,6 +47,13 @@ functions:
           rate: cron(0 12 * * ? *)
           enabled: false
           inputPath: '$.stageVariables'
+      - schedule:
+          rate: rate(2 hours)
+          enabled: true
+          inputTransformer:
+            inputPathsMap:
+              eventTime: '$.time'
+            inputTemplate: '{"time": <eventTime>, "key1": "value1"}'
 ```
 
 ## Specify Name and Description

docs/providers/aws/guide/serverless.yml.md

@@ -200,12 +200,17 @@ functions:
           description: a description of my scheduled event's purpose
           rate: rate(10 minutes)
           enabled: false
+          # Note, you can use only one of input, inputPath, or inputTransformer
           input:
             key1: value1
             key2: value2
             stageParams:
               stage: dev
           inputPath: '$.stageVariables'
+          inputTransformer:
+            inputPathsMap:
+              eventTime: '$.time'
+            inputTemplate: '{"time": <eventTime>, "key1": "value1"}'
       - sns:
           topicName: aggregate
           displayName: Data aggregation pipeline
@@ -238,13 +243,17 @@ functions:
             detail:
               state:
                 - pending
-          # Note: you can either use "input" or "inputPath"
+          # Note, you can use only one of input, inputPath, or inputTransformer
           input:
             key1: value1
             key2: value2
             stageParams:
               stage: dev
           inputPath: '$.stageVariables'
+          inputTransformer:
+            inputPathsMap:
+              eventTime: '$.time'
+            inputTemplate: '{"time": <eventTime>, "key1": "value1"}'
       - cloudwatchLog:
           logGroup: '/aws/lambda/hello'
           filter: '{$.userIdentity.type = Root}'

lib/plugins/aws/package/compile/events/cloudWatchEvent/index.js

@@ -25,6 +25,7 @@ class AwsCompileCloudWatchEventEvents {
             let State;
             let Input;
             let InputPath;
+            let InputTransformer;
             let Description;
             let Name;
 
@@ -45,13 +46,15 @@ class AwsCompileCloudWatchEventEvents {
               }
               Input = event.cloudwatchEvent.input;
               InputPath = event.cloudwatchEvent.inputPath;
+              InputTransformer = event.cloudwatchEvent.inputTransformer;
               Description = event.cloudwatchEvent.description;
               Name = event.cloudwatchEvent.name;
 
-              if (Input && InputPath) {
+              const inputOptions = [Input, InputPath, InputTransformer].filter(i => i);
+              if (inputOptions.length > 1) {
                 const errorMessage = [
-                  'You can\'t set both input & inputPath properties at the',
-                  'same time for cloudwatch events.',
+                  'You can only set one of input, inputPath, or inputTransformer ',
+                  'properties at the same time for cloudwatch events. ',
                   'Please check the AWS docs for more info',
                 ].join('');
                 throw new this.serverless.classes.Error(errorMessage);
@@ -64,6 +67,9 @@ class AwsCompileCloudWatchEventEvents {
                 // escape quotes to favor JSON.parse
                 Input = Input.replace(/\"/g, '\\"'); // eslint-disable-line
               }
+              if (InputTransformer) {
+                InputTransformer = this.formatInputTransformer(InputTransformer);
+              }
             } else {
               const errorMessage = [
                 `CloudWatch event of function "${functionName}" is not an object`,
@@ -93,6 +99,7 @@ class AwsCompileCloudWatchEventEvents {
                   "Targets": [{
                     ${Input ? `"Input": "${Input.replace(/\\n|\\r/g, '')}",` : ''}
                     ${InputPath ? `"InputPath": "${InputPath.replace(/\r?\n/g, '')}",` : ''}
+                    ${InputTransformer ? `"InputTransformer": ${InputTransformer},` : ''}
                     "Arn": { "Fn::GetAtt": ["${lambdaLogicalId}", "Arn"] },
                     "Id": "${cloudWatchId}"
                   }]
@@ -128,6 +135,24 @@ class AwsCompileCloudWatchEventEvents {
       }
     });
   }
+
+  formatInputTransformer(inputTransformer) {
+    if (!inputTransformer.inputTemplate) {
+      throw new this.serverless.classes.Error(
+        'The inputTemplate key is required when specifying an ' +
+        'inputTransformer for a cloudwatchEvent event'
+      );
+    }
+    const cfmOutput = {
+      // InputTemplate is required
+      InputTemplate: inputTransformer.inputTemplate,
+    };
+    // InputPathsMap is optional
+    if (inputTransformer.inputPathsMap) {
+      cfmOutput.InputPathsMap = inputTransformer.inputPathsMap;
+    }
+    return JSON.stringify(cfmOutput);
+  }
 }
 
 module.exports = AwsCompileCloudWatchEventEvents;

lib/plugins/aws/package/compile/events/cloudWatchEvent/index.test.js

@@ -218,6 +218,42 @@ describe('awsCompileCloudWatchEventEvents', () => {
       ).to.equal('{"key":"value"}');
     });
 
+    it('should respect inputTransformer variable', () => {
+      awsCompileCloudWatchEventEvents.serverless.service.functions = {
+        first: {
+          events: [
+            {
+              cloudwatchEvent: {
+                event: {
+                  source: ['aws.ec2'],
+                  'detail-type': ['EC2 Instance State-change Notification'],
+                  detail: { state: ['pending'] },
+                },
+                enabled: false,
+                inputTransformer: {
+                  inputPathsMap: {
+                    eventTime: '$.time',
+                  },
+                  inputTemplate: '{"time": <eventTime>, "key1": "value1"}',
+                },
+              },
+            },
+          ],
+        },
+      };
+
+      awsCompileCloudWatchEventEvents.compileCloudWatchEventEvents();
+
+      expect(awsCompileCloudWatchEventEvents.serverless.service
+        .provider.compiledCloudFormationTemplate.Resources.FirstEventsRuleCloudWatchEvent1
+        .Properties.Targets[0].InputTransformer
+      ).to.eql({
+        InputTemplate: '{"time": <eventTime>, "key1": "value1"}',
+        InputPathsMap: { eventTime: '$.time' },
+      });
+    });
+
+
     it('should respect description variable', () => {
       awsCompileCloudWatchEventEvents.serverless.service.functions = {
         first: {
@@ -328,6 +364,62 @@ describe('awsCompileCloudWatchEventEvents', () => {
       expect(() => awsCompileCloudWatchEventEvents.compileCloudWatchEventEvents()).to.throw(Error);
     });
 
+    it('should throw an error when both Input and InputTransformer are set', () => {
+      awsCompileCloudWatchEventEvents.serverless.service.functions = {
+        first: {
+          events: [
+            {
+              cloudwatchEvent: {
+                event: {
+                  source: ['aws.ec2'],
+                  'detail-type': ['EC2 Instance State-change Notification'],
+                  detail: { state: ['pending'] },
+                },
+                enabled: false,
+                input: {
+                  key: 'value',
+                },
+                inputTransformer: {
+                  inputPathsMap: {
+                    eventTime: '$.time',
+                  },
+                  inputTemplate: '{"time": <eventTime>, "key1": "value1"}',
+                },
+              },
+            },
+          ],
+        },
+      };
+
+      expect(() => awsCompileCloudWatchEventEvents.compileCloudWatchEventEvents()).to.throw(Error);
+    });
+
+    it('should throw an error when inputTransformer does not have inputTemplate', () => {
+      awsCompileCloudWatchEventEvents.serverless.service.functions = {
+        first: {
+          events: [
+            {
+              cloudwatchEvent: {
+                event: {
+                  source: ['aws.ec2'],
+                  'detail-type': ['EC2 Instance State-change Notification'],
+                  detail: { state: ['pending'] },
+                },
+                enabled: false,
+                inputTransformer: {
+                  inputPathsMap: {
+                    eventTime: '$.time',
+                  },
+                },
+              },
+            },
+          ],
+        },
+      };
+
+      expect(() => awsCompileCloudWatchEventEvents.compileCloudWatchEventEvents()).to.throw(Error);
+    });
+
     it('should respect variables if multi-line variables is given', () => {
       awsCompileCloudWatchEventEvents.serverless.service.functions = {
         first: {

lib/plugins/aws/package/compile/events/schedule/index.js

@@ -40,6 +40,7 @@ class AwsCompileScheduledEvents {
             let State;
             let Input;
             let InputPath;
+            let InputTransformer;
             let Name;
             let Description;
 
@@ -56,13 +57,15 @@ class AwsCompileScheduledEvents {
               }
               Input = event.schedule.input;
               InputPath = event.schedule.inputPath;
+              InputTransformer = event.schedule.inputTransformer;
               Name = event.schedule.name;
               Description = event.schedule.description;
 
-              if (Input && InputPath) {
+              const inputOptions = [Input, InputPath, InputTransformer].filter(i => i);
+              if (inputOptions.length > 1) {
                 const errorMessage = [
-                  'You can\'t set both input & inputPath properties at the',
-                  'same time for schedule events.',
+                  'You can only set one of input, inputPath, or inputTransformer ',
+                  'properties at the same time for schedule events. ',
                   'Please check the AWS docs for more info',
                 ].join('');
                 throw new this.serverless.classes
@@ -90,6 +93,9 @@ class AwsCompileScheduledEvents {
                 // escape quotes to favor JSON.parse
                 Input = Input.replace(/\"/g, '\\"'); // eslint-disable-line
               }
+              if (InputTransformer) {
+                InputTransformer = this.formatInputTransformer(InputTransformer);
+              }
             } else if (this.validateScheduleSyntax(event.schedule)) {
               ScheduleExpression = event.schedule;
               State = 'ENABLED';
@@ -118,6 +124,7 @@ class AwsCompileScheduledEvents {
                   "Targets": [{
                     ${Input ? `"Input": "${Input}",` : ''}
                     ${InputPath ? `"InputPath": "${InputPath}",` : ''}
+                    ${InputTransformer ? `"InputTransformer": ${InputTransformer},` : ''}
                     "Arn": { "Fn::GetAtt": ["${lambdaLogicalId}", "Arn"] },
                     "Id": "${scheduleId}"
                   }]
@@ -158,6 +165,24 @@ class AwsCompileScheduledEvents {
     return typeof input === 'string' &&
       (rateSyntaxPattern.test(input) || cronSyntaxPattern.test(input));
   }
+
+  formatInputTransformer(inputTransformer) {
+    if (!inputTransformer.inputTemplate) {
+      throw new this.serverless.classes.Error(
+        'The inputTemplate key is required when specifying an ' +
+        'inputTransformer for a schedule event'
+      );
+    }
+    const cfmOutput = {
+      // InputTemplate is required
+      InputTemplate: inputTransformer.inputTemplate,
+    };
+    // InputPathsMap is optional
+    if (inputTransformer.inputPathsMap) {
+      cfmOutput.InputPathsMap = inputTransformer.inputPathsMap;
+    }
+    return JSON.stringify(cfmOutput);
+  }
 }
 
 module.exports = AwsCompileScheduledEvents;