feat(iotevents): add DetectorModel L2 Construct

packages/@aws-cdk/aws-iotevents/README.md

@@ -40,15 +40,30 @@ Import it into your code:
 import * as iotevents from '@aws-cdk/aws-iotevents';
 ```
 
-## `Input`
+## `DetectorModel`
 
-Add an AWS IoT Events input to your stack:
+The following example creates an AWS IoT Events detector dodel to your stack.
+The detector model need a reference to at least one AWS IoT Events input.
+AWS IoT Events input enable that the detector can get MQTT payload values from IoT Core rules.
 
 ```ts
 import * as iotevents from '@aws-cdk/aws-iotevents';
 
-new iotevents.Input(this, 'MyInput', {
- inputName: 'my_input',
+const input = new iotevents.Input(this, 'MyInput', {
+ inputName: 'my_input', // optional
  attributeJsonPaths: ['payload.temperature'],
 });
+
+const onlineState = new iotevents.State({
+ stateName: 'online',
+ onEnterEvents: [{
+ eventName: 'test-event',
+ condition: iotevents.Expression.currentInput(input),
+ }],
+});
+
+new iotevents.DetectorModel(this, 'MyDetectorModel', {
+ detectorModelName: 'test-detector-model', // optional
+ initialState: onlineState,
+});
 ```

packages/@aws-cdk/aws-iotevents/lib/detector-model.ts

@@ -0,0 +1,82 @@
+import * as iam from '@aws-cdk/aws-iam';
+import { Resource, IResource } from '@aws-cdk/core';
+import { Construct } from 'constructs';
+import { CfnDetectorModel } from './iotevents.generated';
+import { State } from './state';
+
+/**
+ * Represents an AWS IoT Events detector model
+ */
+export interface IDetectorModel extends IResource {
+ /**
+ * The name of the detector model
+ * @attribute
+ */
+ readonly detectorModelName: string;
+}
+
+/**
+ * Properties for defining an AWS IoT Events detector model
+ */
+export interface DetectorModelProps {
+ /**
+ * The name of the detector model
+ *
+ * @default - CloudFormation will generate a unique name of the detector model
+ */
+ readonly detectorModelName?: string;
+
+ /**
+ * The state that is entered at the creation of each detector.
+ */
+ readonly initialState: State;
+
+ /**
+ * The role that grants permission to AWS IoT Events to perform its operations.
+ *
+ * @default - a role will be created with default permissions.
+ */
+ readonly role?: iam.IRole;
+}
+
+/**
+ * Defines an AWS IoT Events detector model in this stack.
+ */
+export class DetectorModel extends Resource implements IDetectorModel {
+ /**
+ * Import an existing detector model
+ */
+ public static fromDetectorModelName(scope: Construct, id: string, detectorModelName: string): IDetectorModel {
+ class Import extends Resource implements IDetectorModel {
+ public readonly detectorModelName = detectorModelName;
+ }
+ return new Import(scope, id);
+ }
+
+ public readonly detectorModelName: string;
+
+ constructor(scope: Construct, id: string, props: DetectorModelProps) {
+ super(scope, id, {
+ physicalName: props.detectorModelName,
+ });
+
+ if (!props.initialState.hasCondition()) {
+ throw new Error('Detector Model must use at least one Input in a condition.');
+ }
+
+ const role = props.role ?? new iam.Role(this, 'DetectorModelRole', {
+ assumedBy: new iam.ServicePrincipal('iotevents.amazonaws.com'),
+ });
+
+ const resource = new CfnDetectorModel(this, 'Resource', {
+ detectorModelName: this.physicalName,
+ detectorModelDefinition: {
+ initialStateName: props.initialState.stateName,
+ states: [props.initialState.toStateJson()],
+ },
+ roleArn: role.roleArn,
+ });
+
+ this.detectorModelName = this.getResourceNameAttribute(resource.ref);
+ }
+}

packages/@aws-cdk/aws-iotevents/lib/event.ts

@@ -0,0 +1,28 @@
+import { Expression } from './expression';
+import { CfnDetectorModel } from './iotevents.generated';
+
+/**
+ * Specifies the actions to be performed when the condition evaluates to TRUE.
+ */
+export interface Event {
+ /**
+ * The name of the event
+ */
+ readonly eventName: string;
+
+ /**
+ * The Boolean expression that, when TRUE, causes the actions to be performed.
+ *
+ * @default None - Defaults to perform the actions always.
+ */
+ readonly condition?: Expression;
+}
+
+export function getEventJson(events: Event[]): CfnDetectorModel.EventProperty[] {
+ return events.map(e => {
+ return {
+ eventName: e.eventName,
+ condition: e.condition?.evaluate(),
+ };
+ });
+}

packages/@aws-cdk/aws-iotevents/lib/expression.ts

@@ -0,0 +1,75 @@
+import { IInput } from './input';
+
+/**
+ * Expression for events in Detector Model state
+ * @see https://docs.aws.amazon.com/iotevents/latest/developerguide/iotevents-expressions.html
+ */
+export abstract class Expression {
+ /**
+ * Create a expression from the given string
+ */
+ public static fromString(value: string): Expression {
+ return new StringExpression(value);
+ }
+
+ /**
+ * Create a expression for function `currentInput()`.
+ * It is evaluated to true if the specified input message was received.
+ */
+ public static currentInput(input: IInput): Expression {
+ return this.fromString(`currentInput("${input.inputName}")`);
+ }
+
+ /**
+ * Create a expression for get an input attribute as `$input.TemperatureInput.temperatures[2]`.
+ */
+ public static inputAttribute(input: IInput, path: string): Expression {
+ return this.fromString(`$input.${input.inputName}.${path}`);
+ }
+
+ /**
+ * Create a expression for the Equal operator
+ */
+ public static eq(left: Expression, right: Expression): Expression {
+ return new BinaryOperationExpression(left, '==', right);
+ }
+
+ /**
+ * Create a expression for the AND operator
+ */
+ public static and(left: Expression, right: Expression): Expression {
+ return new BinaryOperationExpression(left, '&&', right);
+ }
+
+ constructor() {
+ }
+
+ /**
+ * this is called to evaluate the expression
+ */
+ public abstract evaluate(): string;
+}
+
+class StringExpression extends Expression {
+ constructor(private readonly value: string) {
+ super();
+ }
+
+ public evaluate() {
+ return this.value;
+ }
+}
+
+class BinaryOperationExpression extends Expression {
+ constructor(
+ private readonly left: Expression,
+ private readonly operater: string,
+ private readonly right: Expression,
+ ) {
+ super();
+ }
+
+ public evaluate() {
+ return `${this.left.evaluate()} ${this.operater} ${this.right.evaluate()}`;
+ }
+}

packages/@aws-cdk/aws-iotevents/lib/index.ts

@@ -1,4 +1,8 @@
+export * from './detector-model';
+export * from './event';
+export * from './expression';
 export * from './input';
+export * from './state';
 
 // AWS::IoTEvents CloudFormation Resources:
 export * from './iotevents.generated';

packages/@aws-cdk/aws-iotevents/lib/state.ts

@@ -0,0 +1,51 @@
+import { Event, getEventJson } from './event';
+import { CfnDetectorModel } from './iotevents.generated';
+
+/**
+ * Properties for defining a state of a detector
+ */
+export interface StateProps {
+ /**
+ * The name of the state
+ */
+ readonly stateName: string;
+
+ /**
+ * Specifies the actions that are performed when the state is entered and the `condition` is `TRUE`
+ *
+ * @default None
+ */
+ readonly onEnterEvents?: Event[];
+}
+
+/**
+ * Defines a state of a detector
+ */
+export class State {
+ /**
+ * The name of the state
+ */
+ public readonly stateName: string;
+
+ constructor(private readonly props: StateProps) {
+ this.stateName = props.stateName;
+ }
+
+ /**
+ * Return the state property JSON
+ */
+ public toStateJson(): CfnDetectorModel.StateProperty {
+ const { stateName, onEnterEvents } = this.props;
+ return {
+ stateName,
+ onEnter: onEnterEvents && { events: getEventJson(onEnterEvents) },
+ };
+ }
+
+ /**
+ * returns true if this state has at least one condition via events
+ */
+ public hasCondition(): boolean {
+ return this.props.onEnterEvents?.some(event => event.condition) ?? false;
+ }
+}

packages/@aws-cdk/aws-iotevents/package.json

@@ -83,10 +83,12 @@
  "jest": "^27.4.5"
  },
  "dependencies": {
+ "@aws-cdk/aws-iam": "0.0.0",
  "@aws-cdk/core": "0.0.0",
  "constructs": "^3.3.69"
  },
  "peerDependencies": {
+ "@aws-cdk/aws-iam": "0.0.0",
  "@aws-cdk/core": "0.0.0",
  "constructs": "^3.3.69"
  },