# FilterRule

Filter rules for Lambda event filtering.

- Source: [`aws-lambda/lib/event-source-filter.ts`](https://github.com/aws/aws-cdk/blob/v2.277.0/packages/aws-cdk-lib/aws-lambda/lib/event-source-filter.ts#L4)
- Type last changed: v2.163.0 · 22 Oct 2024

## Example

TypeScript:

```ts
import * as dynamodb from 'aws-cdk-lib/aws-dynamodb';
import { DynamoEventSource } from 'aws-cdk-lib/aws-lambda-event-sources';

declare const table: dynamodb.Table;

declare const fn: lambda.Function;
fn.addEventSource(new DynamoEventSource(table, {
  startingPosition: lambda.StartingPosition.LATEST,
  filters: [
    lambda.FilterCriteria.filter({
      eventName: lambda.FilterRule.isEqual('INSERT'),
      dynamodb: {
        NewImage: {
          id: { BOOL: lambda.FilterRule.isEqual(true) },
        },
      },
    }),
  ],
}));
```

Python:

```python
import aws_cdk.aws_dynamodb as dynamodb
from aws_cdk.aws_lambda_event_sources import DynamoEventSource

# table: dynamodb.Table

# fn: lambda.Function

fn.add_event_source(DynamoEventSource(table,
    starting_position=lambda_.StartingPosition.LATEST,
    filters=[
        lambda_.FilterCriteria.filter({
            "event_name": lambda_.FilterRule.is_equal("INSERT"),
            "dynamodb": {
                "NewImage": {
                    "id": {"BOOL": lambda_.FilterRule.is_equal(True)}
                }
            }
        })
    ]
))
```

Java:

```java
import software.amazon.awscdk.services.dynamodb.*;
import software.amazon.awscdk.services.lambda.eventsources.DynamoEventSource;

Table table;

Function fn;

fn.addEventSource(DynamoEventSource.Builder.create(table)
        .startingPosition(StartingPosition.LATEST)
        .filters(List.of(FilterCriteria.filter(Map.of(
                "eventName", FilterRule.isEqual("INSERT"),
                "dynamodb", Map.of(
                        "NewImage", Map.of(
                                "id", Map.of("BOOL", FilterRule.isEqual(true))))))))
        .build());
```

C# / .NET:

```csharp
// Install: dotnet add package Amazon.CDK.Lib
using Amazon.CDK.AWS.DynamoDB;
using Amazon.CDK.AWS.Lambda.EventSources;

Table table;

Function fn;

fn.AddEventSource(new DynamoEventSource(table, new DynamoEventSourceProps {
    StartingPosition = StartingPosition.LATEST,
    Filters = new [] { FilterCriteria.Filter(new Dictionary<string, object> {
        { "eventName", FilterRule.IsEqual("INSERT") },
        { "dynamodb", new Dictionary<string, IDictionary<string, IDictionary<string, object>>> {
            { "NewImage", new Struct {
                Id = new Struct { BOOL = FilterRule.IsEqual(true) }
            } }
        } }
    }) }
}));
```

Golang:

```go
// Install: go get github.com/aws/aws-cdk-go/awscdk/v2
import dynamodb "github.com/aws/aws-cdk-go/awscdk"
import "github.com/aws/aws-cdk-go/awscdk"

var table Table

var fn Function

fn.AddEventSource(awscdk.NewDynamoEventSource(table, &DynamoEventSourceProps{
	StartingPosition: lambda.StartingPosition_LATEST,
	Filters: []map[string]interface{}{
		lambda.FilterCriteria_Filter(map[string]interface{}{
			"eventName": lambda.FilterRule_isEqual(jsii.String("INSERT")),
			"dynamodb": map[string]map[string]map[string]interface{}{
				"NewImage": map[string]map[string]interface{}{
					"id": map[string]interface{}{
						"BOOL": lambda.FilterRule_isEqual(jsii.Boolean(true)),
					},
				},
			},
		}),
	},
}))
```

## Initializer

TypeScript:

```ts
new FilterRule()
```

Python:

```python
FilterRule()
```

Java:

```java
new FilterRule()
```

C# / .NET:

```csharp
new FilterRule()
```

Golang:

```go
NewFilterRule()
```

## Methods

- `beginsWith(elem: string): { [key: string]: string }[]` (static) — Begins with comparison operator.

- `between(first: number, second: number): { [key: string]: any[] }[]` (static) — Numeric range comparison operator.

- `empty(): string[]` (static) — Empty comparison operator.

- `exists(): { [key: string]: boolean }[]` (static) — Exists comparison operator.

- `isEqual(item: string | number | boolean): any` (static) — Equals comparison operator.

- `notEquals(elem: string): { [key: string]: string[] }[]` (static) — Not equals comparison operator.

- `notExists(): { [key: string]: boolean }[]` (static) — Not exists comparison operator.

- `null(): any` (static) — Null comparison operator.

- `or(...elem: string[]): string[]` (static) — Or comparison operator.
