@aws-cdk/mixins-preview

CDK Mixins

Version 2.275.0-alpha.0

Separate package

@aws-cdk/mixins-preview is not part of aws-cdk-lib — install it separately:

npm install @aws-cdk/mixins-preview
pip install aws-cdk.mixins-preview

This module is experimental (alpha): its API may change in any release, without a major version bump.

Note: The core Mixins mechanism is now GA and available in constructs and aws-cdk-lib (Mixins, Mixin, IMixin, MixinApplicator, ConstructSelector). All service Mixins are now available in aws-cdk-lib. Please update your imports.

This package continues to provide Logs Delivery Mixins and EventBridge Event Facades, which are still experimental.

---

The APIs of higher level constructs in this module are experimental and under active development. They are subject to non-backward compatible changes or removal in any future version. These are not subject to the Semantic Versioning model and breaking changes will be announced in the release notes. This means that while you may use them, you may need to update your source code when upgrading to a newer version of this package.

---

CDK Mixins provide a new, advanced way to add functionality through composable abstractions. Unlike traditional L2 constructs that bundle all features together, Mixins allow you to pick and choose exactly the capabilities you need for constructs. Mixins can be applied during or after construct construction. Mixins are an addition, not a replacement for construct properties. By itself, they cannot change optionality of properties or change defaults.

Usage and documentation

See the documentation for CDK Mixins in aws-cdk-lib.

Built-in Mixins

Logs Delivery

Configures vended logs delivery for supported resources to various destinations:

import * as cloudfrontMixins from '@aws-cdk/mixins-preview/aws-cloudfront/mixins';

// Create CloudFront distribution
declare const origin: s3.IBucket;
const distribution = new cloudfront.Distribution(scope, 'Distribution', {
  defaultBehavior: {
    origin: origins.S3BucketOrigin.withOriginAccessControl(origin),
  },
});

// Create log destination
const logGroup = new logs.LogGroup(scope, 'DeliveryLogGroup');

// Configure log delivery using the mixin
distribution
  .with(cloudfrontMixins.CfnDistributionLogsMixin.CONNECTION_LOGS.toLogGroup(logGroup, {
    outputFormat: cloudfrontMixins.CfnDistributionConnectionLogsOutputFormat.LogGroup.JSON,
    recordFields: [
      cloudfrontMixins.CfnDistributionConnectionLogsRecordFields.CONNECTIONSTATUS,
      cloudfrontMixins.CfnDistributionConnectionLogsRecordFields.CLIENTIP,
      cloudfrontMixins.CfnDistributionConnectionLogsRecordFields.SERVERIP,
      cloudfrontMixins.CfnDistributionConnectionLogsRecordFields.TLSPROTOCOL,
    ],
  }));

import aws_cdk.mixins_preview.aws_cloudfront.mixins as cloudfront_mixins

# Create CloudFront distribution
# origin: s3.IBucket

distribution = cloudfront.Distribution(scope, "Distribution",
    default_behavior=cloudfront.BehaviorOptions(
        origin=origins.S3BucketOrigin.with_origin_access_control(origin)
    )
)

# Create log destination
log_group = logs.LogGroup(scope, "DeliveryLogGroup")

# Configure log delivery using the mixin
distribution.with(cloudfront_mixins.CfnDistributionLogsMixin.CONNECTION_LOGS.to_log_group(log_group,
    output_format=cloudfront_mixins.CfnDistributionConnectionLogsOutputFormat.LogGroup.JSON,
    record_fields=[cloudfront_mixins.CfnDistributionConnectionLogsRecordFields.CONNECTIONSTATUS, cloudfront_mixins.CfnDistributionConnectionLogsRecordFields.CLIENTIP, cloudfront_mixins.CfnDistributionConnectionLogsRecordFields.SERVERIP, cloudfront_mixins.CfnDistributionConnectionLogsRecordFields.TLSPROTOCOL
    ]
))

import software.amazon.awscdk.mixins.preview.services.cloudfront.mixins.*;

// Create CloudFront distribution
IBucket origin;

Distribution distribution = Distribution.Builder.create(scope, "Distribution")
        .defaultBehavior(BehaviorOptions.builder()
                .origin(S3BucketOrigin.withOriginAccessControl(origin))
                .build())
        .build();

// Create log destination
LogGroup logGroup = new LogGroup(scope, "DeliveryLogGroup");

// Configure log delivery using the mixin
distribution.with(CfnDistributionLogsMixin.CONNECTION_LOGS.toLogGroup(logGroup, CfnDistributionConnectionLogsLogGroupProps.builder()
        .outputFormat(CfnDistributionConnectionLogsOutputFormat.getLogGroup().JSON)
        .recordFields(List.of(CfnDistributionConnectionLogsRecordFields.CONNECTIONSTATUS, CfnDistributionConnectionLogsRecordFields.CLIENTIP, CfnDistributionConnectionLogsRecordFields.SERVERIP, CfnDistributionConnectionLogsRecordFields.TLSPROTOCOL))
        .build()));

using Amazon.CDK.Mixins.Preview.AWS.CloudFront.Mixins;

// Create CloudFront distribution
IBucket origin;

var distribution = new Distribution(scope, "Distribution", new DistributionProps {
    DefaultBehavior = new BehaviorOptions {
        Origin = S3BucketOrigin.WithOriginAccessControl(origin)
    }
});

// Create log destination
var logGroup = new LogGroup(scope, "DeliveryLogGroup");

// Configure log delivery using the mixin
distribution.With(CfnDistributionLogsMixin.CONNECTION_LOGS.ToLogGroup(logGroup, new CfnDistributionConnectionLogsLogGroupProps {
    OutputFormat = CfnDistributionConnectionLogsOutputFormat.LogGroup.JSON,
    RecordFields = new [] { CfnDistributionConnectionLogsRecordFields.CONNECTIONSTATUS, CfnDistributionConnectionLogsRecordFields.CLIENTIP, CfnDistributionConnectionLogsRecordFields.SERVERIP, CfnDistributionConnectionLogsRecordFields.TLSPROTOCOL }
}));

import "github.com/aws/aws-cdk-go/awscdkmixinspreview"

// Create CloudFront distribution
var origin IBucket

distribution := cloudfront.NewDistribution(scope, jsii.String("Distribution"), &DistributionProps{
	DefaultBehavior: &BehaviorOptions{
		Origin: origins.S3BucketOrigin_WithOriginAccessControl(origin),
	},
})

// Create log destination
logGroup := logs.NewLogGroup(scope, jsii.String("DeliveryLogGroup"))

// Configure log delivery using the mixin
distribution.With(cloudfrontMixins.CfnDistributionLogsMixin_CONNECTION_LOGS().ToLogGroup(logGroup, &CfnDistributionConnectionLogsLogGroupProps{
	OutputFormat: cloudfrontMixins.CfnDistributionConnectionLogsOutputFormat.LogGroup_JSON,
	RecordFields: []CfnDistributionConnectionLogsRecordFields{
		cloudfrontMixins.CfnDistributionConnectionLogsRecordFields_CONNECTIONSTATUS,
		cloudfrontMixins.CfnDistributionConnectionLogsRecordFields_CLIENTIP,
		cloudfrontMixins.CfnDistributionConnectionLogsRecordFields_SERVERIP,
		cloudfrontMixins.CfnDistributionConnectionLogsRecordFields_TLSPROTOCOL,
	},
}))

Configures vended logs delivery for supported resources when a pre-created destination is provided:

import * as cloudfrontMixins from '@aws-cdk/mixins-preview/aws-cloudfront/mixins';

// Create CloudFront distribution
declare const origin: s3.IBucket;
const distribution = new cloudfront.Distribution(scope, 'Distribution', {
  defaultBehavior: {
    origin: origins.S3BucketOrigin.withOriginAccessControl(origin),
  },
});

// Create destination bucket
const destBucket = new s3.Bucket(scope, 'DeliveryBucket');
// Add permissions to bucket to facilitate log delivery
const bucketPolicy = new s3.BucketPolicy(scope, 'DeliveryBucketPolicy', {
  bucket: destBucket,
  document: new iam.PolicyDocument(),
});
// Create S3 delivery destination for logs
const destination = new logs.CfnDeliveryDestination(scope, 'Destination', {
  destinationResourceArn: destBucket.bucketArn,
  name: 'unique-destination-name',
  deliveryDestinationType: 'S3',
});

distribution
  .with(cloudfrontMixins.CfnDistributionLogsMixin.CONNECTION_LOGS.toDestination(destination));

import aws_cdk.mixins_preview.aws_cloudfront.mixins as cloudfront_mixins

# Create CloudFront distribution
# origin: s3.IBucket

distribution = cloudfront.Distribution(scope, "Distribution",
    default_behavior=cloudfront.BehaviorOptions(
        origin=origins.S3BucketOrigin.with_origin_access_control(origin)
    )
)

# Create destination bucket
dest_bucket = s3.Bucket(scope, "DeliveryBucket")
# Add permissions to bucket to facilitate log delivery
bucket_policy = s3.BucketPolicy(scope, "DeliveryBucketPolicy",
    bucket=dest_bucket,
    document=iam.PolicyDocument()
)
# Create S3 delivery destination for logs
destination = logs.CfnDeliveryDestination(scope, "Destination",
    destination_resource_arn=dest_bucket.bucket_arn,
    name="unique-destination-name",
    delivery_destination_type="S3"
)

distribution.with(cloudfront_mixins.CfnDistributionLogsMixin.CONNECTION_LOGS.to_destination(destination))

import software.amazon.awscdk.mixins.preview.services.cloudfront.mixins.*;

// Create CloudFront distribution
IBucket origin;

Distribution distribution = Distribution.Builder.create(scope, "Distribution")
        .defaultBehavior(BehaviorOptions.builder()
                .origin(S3BucketOrigin.withOriginAccessControl(origin))
                .build())
        .build();

// Create destination bucket
Bucket destBucket = new Bucket(scope, "DeliveryBucket");
// Add permissions to bucket to facilitate log delivery
BucketPolicy bucketPolicy = BucketPolicy.Builder.create(scope, "DeliveryBucketPolicy")
        .bucket(destBucket)
        .document(new PolicyDocument())
        .build();
// Create S3 delivery destination for logs
CfnDeliveryDestination destination = CfnDeliveryDestination.Builder.create(scope, "Destination")
        .destinationResourceArn(destBucket.getBucketArn())
        .name("unique-destination-name")
        .deliveryDestinationType("S3")
        .build();

distribution.with(CfnDistributionLogsMixin.CONNECTION_LOGS.toDestination(destination));

using Amazon.CDK.Mixins.Preview.AWS.CloudFront.Mixins;

// Create CloudFront distribution
IBucket origin;

var distribution = new Distribution(scope, "Distribution", new DistributionProps {
    DefaultBehavior = new BehaviorOptions {
        Origin = S3BucketOrigin.WithOriginAccessControl(origin)
    }
});

// Create destination bucket
var destBucket = new Bucket(scope, "DeliveryBucket");
// Add permissions to bucket to facilitate log delivery
var bucketPolicy = new BucketPolicy(scope, "DeliveryBucketPolicy", new BucketPolicyProps {
    Bucket = destBucket,
    Document = new PolicyDocument()
});
// Create S3 delivery destination for logs
var destination = new CfnDeliveryDestination(scope, "Destination", new CfnDeliveryDestinationProps {
    DestinationResourceArn = destBucket.BucketArn,
    Name = "unique-destination-name",
    DeliveryDestinationType = "S3"
});

distribution.With(CfnDistributionLogsMixin.CONNECTION_LOGS.ToDestination(destination));

import cloudfrontMixins "github.com/aws/aws-cdk-go/awscdkmixinspreview"

// Create CloudFront distribution
var origin IBucket

distribution := cloudfront.NewDistribution(scope, jsii.String("Distribution"), &DistributionProps{
	DefaultBehavior: &BehaviorOptions{
		Origin: origins.S3BucketOrigin_WithOriginAccessControl(origin),
	},
})

// Create destination bucket
destBucket := s3.NewBucket(scope, jsii.String("DeliveryBucket"))
// Add permissions to bucket to facilitate log delivery
bucketPolicy := s3.NewBucketPolicy(scope, jsii.String("DeliveryBucketPolicy"), &BucketPolicyProps{
	Bucket: destBucket,
	Document: iam.NewPolicyDocument(),
})
// Create S3 delivery destination for logs
destination := logs.NewCfnDeliveryDestination(scope, jsii.String("Destination"), &CfnDeliveryDestinationProps{
	DestinationResourceArn: destBucket.bucketArn,
	Name: jsii.String("unique-destination-name"),
	DeliveryDestinationType: jsii.String("S3"),
})

distribution.With(cloudfrontMixins.CfnDistributionLogsMixin_CONNECTION_LOGS().ToDestination(destination))

Vended Logs Configuration for Cross Account delivery (only supported for S3 and Firehose destinations)

import * as logDestinations from '@aws-cdk/mixins-preview/aws-logs';
import * as cloudfrontMixins from '@aws-cdk/mixins-preview/aws-cloudfront/mixins';

const destinationAccount = '123456789012';
const sourceAccount = '234567890123';
const region = 'us-east-1';

const app = new App();

const destStack = new Stack(app, 'destination-stack', {
  env: {
    account: destinationAccount,
    region,
  },
});

// Create destination bucket
const destBucket = new s3.Bucket(destStack, 'DeliveryBucket');
new logDestinations.S3DeliveryDestination(destStack, 'Destination', {
  bucket: destBucket,
  sourceAccountId: sourceAccount,
});

const sourceStack = new Stack(app, 'source-stack', {
  env: {
    account: sourceAccount,
    region,
  },
});

// Create CloudFront distribution
declare const origin: s3.IBucket;
const distribution = new cloudfront.Distribution(sourceStack, 'Distribution', {
  defaultBehavior: {
    origin: origins.S3BucketOrigin.withOriginAccessControl(origin),
  },
});

const destination = logs.CfnDeliveryDestination.fromDeliveryDestinationArn(sourceStack, 'Destination', `arn of Delivery Destination in destinationAccount`);

distribution
  .with(cloudfrontMixins.CfnDistributionLogsMixin.CONNECTION_LOGS.toDestination(destination));

from aws_cdk import Environment, Environment
import aws_cdk.mixins_preview.aws_logs as log_destinations
import aws_cdk.mixins_preview.aws_cloudfront.mixins as cloudfront_mixins

# Create CloudFront distribution
# origin: s3.IBucket


destination_account = "123456789012"
source_account = "234567890123"
region = "us-east-1"

app = App()

dest_stack = Stack(app, "destination-stack",
    env=Environment(
        account=destination_account,
        region=region
    )
)

# Create destination bucket
dest_bucket = s3.Bucket(dest_stack, "DeliveryBucket")
log_destinations.S3DeliveryDestination(dest_stack, "Destination",
    bucket=dest_bucket,
    source_account_id=source_account
)

source_stack = Stack(app, "source-stack",
    env=Environment(
        account=source_account,
        region=region
    )
)
distribution = cloudfront.Distribution(source_stack, "Distribution",
    default_behavior=cloudfront.BehaviorOptions(
        origin=origins.S3BucketOrigin.with_origin_access_control(origin)
    )
)

destination = logs.CfnDeliveryDestination.from_delivery_destination_arn(source_stack, "Destination", "arn of Delivery Destination in destinationAccount")

distribution.with(cloudfront_mixins.CfnDistributionLogsMixin.CONNECTION_LOGS.to_destination(destination))

import software.amazon.awscdk.mixins.preview.services.logs.*;
import software.amazon.awscdk.mixins.preview.services.cloudfront.mixins.*;

// Create CloudFront distribution
IBucket origin;


String destinationAccount = "123456789012";
String sourceAccount = "234567890123";
String region = "us-east-1";

App app = new App();

Stack destStack = Stack.Builder.create(app, "destination-stack")
        .env(Environment.builder()
                .account(destinationAccount)
                .region(region)
                .build())
        .build();

// Create destination bucket
Bucket destBucket = new Bucket(destStack, "DeliveryBucket");
S3DeliveryDestination.Builder.create(destStack, "Destination")
        .bucket(destBucket)
        .sourceAccountId(sourceAccount)
        .build();

Stack sourceStack = Stack.Builder.create(app, "source-stack")
        .env(Environment.builder()
                .account(sourceAccount)
                .region(region)
                .build())
        .build();
Distribution distribution = Distribution.Builder.create(sourceStack, "Distribution")
        .defaultBehavior(BehaviorOptions.builder()
                .origin(S3BucketOrigin.withOriginAccessControl(origin))
                .build())
        .build();

IDeliveryDestinationRef destination = CfnDeliveryDestination.fromDeliveryDestinationArn(sourceStack, "Destination", "arn of Delivery Destination in destinationAccount");

distribution.with(CfnDistributionLogsMixin.CONNECTION_LOGS.toDestination(destination));

using Amazon.CDK.Mixins.Preview.AWS.Logs;
using Amazon.CDK.Mixins.Preview.AWS.CloudFront.Mixins;

// Create CloudFront distribution
IBucket origin;


var destinationAccount = "123456789012";
var sourceAccount = "234567890123";
var region = "us-east-1";

var app = new App();

var destStack = new Stack(app, "destination-stack", new StackProps {
    Env = new Environment {
        Account = destinationAccount,
        Region = region
    }
});

// Create destination bucket
var destBucket = new Bucket(destStack, "DeliveryBucket");
new S3DeliveryDestination(destStack, "Destination", new S3DeliveryDestinationProps {
    Bucket = destBucket,
    SourceAccountId = sourceAccount
});

var sourceStack = new Stack(app, "source-stack", new StackProps {
    Env = new Environment {
        Account = sourceAccount,
        Region = region
    }
});
var distribution = new Distribution(sourceStack, "Distribution", new DistributionProps {
    DefaultBehavior = new BehaviorOptions {
        Origin = S3BucketOrigin.WithOriginAccessControl(origin)
    }
});

var destination = CfnDeliveryDestination.FromDeliveryDestinationArn(sourceStack, "Destination", "arn of Delivery Destination in destinationAccount");

distribution.With(CfnDistributionLogsMixin.CONNECTION_LOGS.ToDestination(destination));

import logDestinations "github.com/aws/aws-cdk-go/awscdkmixinspreview"
import cloudfrontMixins "github.com/aws/aws-cdk-go/awscdkmixinspreview"

// Create CloudFront distribution
var origin IBucket


destinationAccount := "123456789012"
sourceAccount := "234567890123"
region := "us-east-1"

app := awscdk.NewApp()

destStack := awscdk.NewStack(app, jsii.String("destination-stack"), &StackProps{
	Env: &Environment{
		Account: destinationAccount,
		Region: jsii.String(*Region),
	},
})

// Create destination bucket
destBucket := s3.NewBucket(destStack, jsii.String("DeliveryBucket"))
logDestinations.NewS3DeliveryDestination(destStack, jsii.String("Destination"), &S3DeliveryDestinationProps{
	Bucket: destBucket,
	SourceAccountId: sourceAccount,
})

sourceStack := awscdk.NewStack(app, jsii.String("source-stack"), &StackProps{
	Env: &Environment{
		Account: sourceAccount,
		Region: jsii.String(*Region),
	},
})
distribution := cloudfront.NewDistribution(sourceStack, jsii.String("Distribution"), &DistributionProps{
	DefaultBehavior: &BehaviorOptions{
		Origin: origins.S3BucketOrigin_WithOriginAccessControl(origin),
	},
})

destination := logs.CfnDeliveryDestination_FromDeliveryDestinationArn(sourceStack, jsii.String("Destination"), jsii.String("arn of Delivery Destination in destinationAccount"))

distribution.With(cloudfrontMixins.CfnDistributionLogsMixin_CONNECTION_LOGS().ToDestination(destination))

---

EventBridge Event Patterns

CDK Mixins automatically generates typed EventBridge event patterns for AWS resources. These patterns come in two flavors: resource-specific and standalone.

Resource-Specific Event Patterns

Resource-specific patterns are created by attaching a resource reference (e.g. an S3 bucket). The resource identifier is automatically injected into the event pattern, so calling a pattern method with no arguments still filters events to that specific resource. For example, an S3 objectCreatedPattern() will automatically include the bucket name in the pattern, meaning it only matches events from that particular bucket.

Event Patterns Basic Usage

import { BucketEvents } from '@aws-cdk/mixins-preview/aws-s3/events';
import * as events from 'aws-cdk-lib/aws-events';
import * as targets from 'aws-cdk-lib/aws-events-targets';

// Works with L2 constructs
const myBucket = new s3.Bucket(scope, 'Bucket');
const bucketEvents = BucketEvents.fromBucket(myBucket);
declare const fn: lambda.Function;

new events.Rule(scope, 'Rule', {
  eventPattern: bucketEvents.objectCreatedPattern({
    object: { key: events.Match.wildcard('uploads/*') },
  }),
  targets: [new targets.LambdaFunction(fn)]
});

// Also works with L1 constructs
const cfnBucket = new s3.CfnBucket(scope, 'CfnBucket');
const cfnBucketEvents = BucketEvents.fromBucket(cfnBucket);

new events.CfnRule(scope, 'CfnRule', {
  state: 'ENABLED',
  eventPattern: cfnBucketEvents.objectCreatedPattern({
    object: { key: events.Match.wildcard('uploads/*') },
  }),
  targets: [{ arn: fn.functionArn, id: 'L1' }]
});

from aws_cdk.mixins_preview.aws_s3.events.ObjectType import ObjectType, ObjectType
from aws_cdk.mixins_preview.aws_s3.events import BucketEvents
import aws_cdk.aws_events as events
import aws_cdk.aws_events_targets as targets
# fn: lambda.Function


# Works with L2 constructs
my_bucket = s3.Bucket(scope, "Bucket")
bucket_events = BucketEvents.from_bucket(my_bucket)

events.Rule(scope, "Rule",
    event_pattern=bucket_events.object_created_pattern(
        object=ObjectType(key=events.Match.wildcard("uploads/*"))
    ),
    targets=[targets.LambdaFunction(fn)]
)

# Also works with L1 constructs
cfn_bucket = s3.CfnBucket(scope, "CfnBucket")
cfn_bucket_events = BucketEvents.from_bucket(cfn_bucket)

events.CfnRule(scope, "CfnRule",
    state="ENABLED",
    event_pattern=cfn_bucket_events.object_created_pattern(
        object=ObjectType(key=events.Match.wildcard("uploads/*"))
    ),
    targets=[events.CfnRule.TargetProperty(arn=fn.function_arn, id="L1")]
)

import software.amazon.awscdk.mixins.preview.services.s3.events.BucketEvents;
import software.amazon.awscdk.services.events.*;
import software.amazon.awscdk.services.events.targets.*;
Function fn;


// Works with L2 constructs
Bucket myBucket = new Bucket(scope, "Bucket");
BucketEvents bucketEvents = BucketEvents.fromBucket(myBucket);

Rule.Builder.create(scope, "Rule")
        .eventPattern(bucketEvents.objectCreatedPattern(ObjectCreatedProps.builder()
                .object(ObjectType.builder().key(Match.wildcard("uploads/*")).build())
                .build()))
        .targets(List.of(new LambdaFunction(fn)))
        .build();

// Also works with L1 constructs
CfnBucket cfnBucket = new CfnBucket(scope, "CfnBucket");
BucketEvents cfnBucketEvents = BucketEvents.fromBucket(cfnBucket);

CfnRule.Builder.create(scope, "CfnRule")
        .state("ENABLED")
        .eventPattern(cfnBucketEvents.objectCreatedPattern(ObjectCreatedProps.builder()
                .object(ObjectType.builder().key(Match.wildcard("uploads/*")).build())
                .build()))
        .targets(List.of(TargetProperty.builder().arn(fn.getFunctionArn()).id("L1").build()))
        .build();

using Amazon.CDK.Mixins.Preview.AWS.S3.Events;
using Amazon.CDK.AWS.Events;
using Amazon.CDK.AWS.Events.Targets;
Function fn;


// Works with L2 constructs
var myBucket = new Bucket(scope, "Bucket");
var bucketEvents = BucketEvents.FromBucket(myBucket);

new Rule(scope, "Rule", new RuleProps {
    EventPattern = bucketEvents.ObjectCreatedPattern(new ObjectCreatedProps {
        Object = new ObjectType { Key = Match.Wildcard("uploads/*") }
    }),
    Targets = new [] { new LambdaFunction(fn) }
});

// Also works with L1 constructs
var cfnBucket = new CfnBucket(scope, "CfnBucket");
var cfnBucketEvents = BucketEvents.FromBucket(cfnBucket);

new CfnRule(scope, "CfnRule", new CfnRuleProps {
    State = "ENABLED",
    EventPattern = cfnBucketEvents.ObjectCreatedPattern(new ObjectCreatedProps {
        Object = new ObjectType { Key = Match.Wildcard("uploads/*") }
    }),
    Targets = new [] { new TargetProperty { Arn = fn.FunctionArn, Id = "L1" } }
});

import "github.com/aws/aws-cdk-go/awscdkmixinspreview"
import "github.com/aws/aws-cdk-go/awscdk"
import targets "github.com/aws/aws-cdk-go/awscdk"
var fn Function


// Works with L2 constructs
myBucket := s3.NewBucket(scope, jsii.String("Bucket"))
bucketEvents := awscdkmixinspreview.BucketEvents_FromBucket(myBucket)

events.NewRule(scope, jsii.String("Rule"), &RuleProps{
	EventPattern: bucketEvents.ObjectCreatedPattern(&ObjectCreatedProps{
		Object: &ObjectType{
			Key: events.Match_Wildcard(jsii.String("uploads/*")),
		},
	}),
	Targets: []IRuleTarget{
		targets.NewLambdaFunction(fn),
	},
})

// Also works with L1 constructs
cfnBucket := s3.NewCfnBucket(scope, jsii.String("CfnBucket"))
cfnBucketEvents := awscdkmixinspreview.BucketEvents_FromBucket(cfnBucket)

events.NewCfnRule(scope, jsii.String("CfnRule"), &CfnRuleProps{
	State: jsii.String("ENABLED"),
	EventPattern: cfnBucketEvents.*ObjectCreatedPattern(&ObjectCreatedProps{
		Object: &ObjectType{
			Key: events.Match_*Wildcard(jsii.String("uploads/*")),
		},
	}),
	Targets: []interface{}{
		&TargetProperty{
			Arn: fn.functionArn,
			Id: jsii.String("L1"),
		},
	},
})

Event Pattern Features

import { BucketEvents } from '@aws-cdk/mixins-preview/aws-s3/events';

const bucketEvents = BucketEvents.fromBucket(bucket);

// Bucket name is automatically injected from the bucket reference
const pattern = bucketEvents.objectCreatedPattern();
// pattern.detail.bucket.name === bucket.bucketName

from aws_cdk.mixins_preview.aws_s3.events import BucketEvents


bucket_events = BucketEvents.from_bucket(bucket)

# Bucket name is automatically injected from the bucket reference
pattern = bucket_events.object_created_pattern()

import software.amazon.awscdk.mixins.preview.services.s3.events.BucketEvents;


BucketEvents bucketEvents = BucketEvents.fromBucket(bucket);

// Bucket name is automatically injected from the bucket reference
EventPattern pattern = bucketEvents.objectCreatedPattern();

using Amazon.CDK.Mixins.Preview.AWS.S3.Events;


var bucketEvents = BucketEvents.FromBucket(bucket);

// Bucket name is automatically injected from the bucket reference
var pattern = bucketEvents.ObjectCreatedPattern();

import "github.com/aws/aws-cdk-go/awscdkmixinspreview"


bucketEvents := awscdkmixinspreview.BucketEvents_FromBucket(bucket)

// Bucket name is automatically injected from the bucket reference
pattern := bucketEvents.ObjectCreatedPattern()

Event Metadata Support: Control EventBridge pattern metadata

import { BucketEvents } from '@aws-cdk/mixins-preview/aws-s3/events';
import * as events from 'aws-cdk-lib/aws-events';

const bucketEvents = BucketEvents.fromBucket(bucket);

const pattern = bucketEvents.objectCreatedPattern({
  eventMetadata: {
    region: events.Match.prefix('us-'),
    version: ['0']
  }
});

from aws_cdk import AWSEventMetadataProps
from aws_cdk.mixins_preview.aws_s3.events import BucketEvents
import aws_cdk.aws_events as events


bucket_events = BucketEvents.from_bucket(bucket)

pattern = bucket_events.object_created_pattern(
    event_metadata=AWSEventMetadataProps(
        region=events.Match.prefix("us-"),
        version=["0"]
    )
)

import software.amazon.awscdk.mixins.preview.services.s3.events.BucketEvents;
import software.amazon.awscdk.services.events.*;


BucketEvents bucketEvents = BucketEvents.fromBucket(bucket);

EventPattern pattern = bucketEvents.objectCreatedPattern(ObjectCreatedProps.builder()
        .eventMetadata(AWSEventMetadataProps.builder()
                .region(Match.prefix("us-"))
                .version(List.of("0"))
                .build())
        .build());

using Amazon.CDK.Mixins.Preview.AWS.S3.Events;
using Amazon.CDK.AWS.Events;


var bucketEvents = BucketEvents.FromBucket(bucket);

var pattern = bucketEvents.ObjectCreatedPattern(new ObjectCreatedProps {
    EventMetadata = new AWSEventMetadataProps {
        Region = Match.Prefix("us-"),
        Version = new [] { "0" }
    }
});

import "github.com/aws/aws-cdk-go/awscdkmixinspreview"
import events "github.com/aws/aws-cdk-go/awscdk"


bucketEvents := awscdkmixinspreview.BucketEvents_FromBucket(bucket)

pattern := bucketEvents.ObjectCreatedPattern(&ObjectCreatedProps{
	EventMetadata: &AWSEventMetadataProps{
		Region: events.Match_Prefix(jsii.String("us-")),
		Version: []*string{
			jsii.String("0"),
		},
	},
})

Standalone Event Patterns

Standalone patterns are not tied to any specific resource. They match events across all resources of that type. For example, a standalone AWSAPICallViaCloudTrail.eventPattern() will match CloudTrail API calls for all S3 buckets in the account, not just a specific one.

Event Patterns Basic Usage

import { AWSAPICallViaCloudTrail, ObjectCreated, ObjectDeleted } from '@aws-cdk/mixins-preview/aws-s3/events';
import * as events from 'aws-cdk-lib/aws-events';
import * as targets from 'aws-cdk-lib/aws-events-targets';

declare const fn: lambda.Function;

// Works with L2 Rule
new events.Rule(scope, 'Rule', {
  eventPattern: AWSAPICallViaCloudTrail.eventPattern({
    tlsDetails: { tlsVersion: ['TLSv1.3'] },
    eventMetadata: { region: ['us-east-1'] },
  }),
  targets: [new targets.LambdaFunction(fn)]
});

// Also works with L1 CfnRule
new events.CfnRule(scope, 'CfnRule', {
  state: 'ENABLED',
  eventPattern: AWSAPICallViaCloudTrail.eventPattern({
    tlsDetails: { tlsVersion: ['TLSv1.3'] },
    eventMetadata: { region: ['us-east-1'] },
  }),
  targets: [{ arn: fn.functionArn, id: 'L1' }]
});

from aws_cdk import AWSEventMetadataProps, AWSEventMetadataProps
from aws_cdk.mixins_preview.aws_s3.events import AWSAPICallViaCloudTrail, ObjectCreated, ObjectDeleted
import aws_cdk.aws_events as events
import aws_cdk.aws_events_targets as targets

# fn: lambda.Function


# Works with L2 Rule
events.Rule(scope, "Rule",
    event_pattern=AWSAPICallViaCloudTrail.event_pattern(
        tls_details=AWSAPICallViaCloudTrail.TlsDetails(tls_version=["TLSv1.3"]),
        event_metadata=AWSEventMetadataProps(region=["us-east-1"])
    ),
    targets=[targets.LambdaFunction(fn)]
)

# Also works with L1 CfnRule
events.CfnRule(scope, "CfnRule",
    state="ENABLED",
    event_pattern=AWSAPICallViaCloudTrail.event_pattern(
        tls_details=AWSAPICallViaCloudTrail.TlsDetails(tls_version=["TLSv1.3"]),
        event_metadata=AWSEventMetadataProps(region=["us-east-1"])
    ),
    targets=[events.CfnRule.TargetProperty(arn=fn.function_arn, id="L1")]
)

import software.amazon.awscdk.mixins.preview.services.s3.events.AWSAPICallViaCloudTrail;
import software.amazon.awscdk.mixins.preview.services.s3.events.ObjectCreated;
import software.amazon.awscdk.mixins.preview.services.s3.events.ObjectDeleted;
import software.amazon.awscdk.services.events.*;
import software.amazon.awscdk.services.events.targets.*;

Function fn;


// Works with L2 Rule
// Works with L2 Rule
Rule.Builder.create(scope, "Rule")
        .eventPattern(AWSAPICallViaCloudTrail.eventPattern(AWSAPICallViaCloudTrailProps.builder()
                .tlsDetails(TlsDetails.builder().tlsVersion(List.of("TLSv1.3")).build())
                .eventMetadata(AWSEventMetadataProps.builder().region(List.of("us-east-1")).build())
                .build()))
        .targets(List.of(new LambdaFunction(fn)))
        .build();

// Also works with L1 CfnRule
// Also works with L1 CfnRule
CfnRule.Builder.create(scope, "CfnRule")
        .state("ENABLED")
        .eventPattern(AWSAPICallViaCloudTrail.eventPattern(AWSAPICallViaCloudTrailProps.builder()
                .tlsDetails(TlsDetails.builder().tlsVersion(List.of("TLSv1.3")).build())
                .eventMetadata(AWSEventMetadataProps.builder().region(List.of("us-east-1")).build())
                .build()))
        .targets(List.of(TargetProperty.builder().arn(fn.getFunctionArn()).id("L1").build()))
        .build();

using Amazon.CDK.Mixins.Preview.AWS.S3.Events;
using Amazon.CDK.AWS.Events;
using Amazon.CDK.AWS.Events.Targets;

Function fn;


// Works with L2 Rule
// Works with L2 Rule
new Rule(scope, "Rule", new RuleProps {
    EventPattern = AWSAPICallViaCloudTrail.EventPattern(new AWSAPICallViaCloudTrailProps {
        TlsDetails = new TlsDetails { TlsVersion = new [] { "TLSv1.3" } },
        EventMetadata = new AWSEventMetadataProps { Region = new [] { "us-east-1" } }
    }),
    Targets = new [] { new LambdaFunction(fn) }
});

// Also works with L1 CfnRule
// Also works with L1 CfnRule
new CfnRule(scope, "CfnRule", new CfnRuleProps {
    State = "ENABLED",
    EventPattern = AWSAPICallViaCloudTrail.EventPattern(new AWSAPICallViaCloudTrailProps {
        TlsDetails = new TlsDetails { TlsVersion = new [] { "TLSv1.3" } },
        EventMetadata = new AWSEventMetadataProps { Region = new [] { "us-east-1" } }
    }),
    Targets = new [] { new TargetProperty { Arn = fn.FunctionArn, Id = "L1" } }
});

import "github.com/aws/aws-cdk-go/awscdkmixinspreview"
import "github.com/aws/aws-cdk-go/awscdk"
import targets "github.com/aws/aws-cdk-go/awscdk"

var fn Function


// Works with L2 Rule
// Works with L2 Rule
events.NewRule(scope, jsii.String("Rule"), &RuleProps{
	EventPattern: awscdkmixinspreview.AWSAPICallViaCloudTrail_EventPattern(&AWSAPICallViaCloudTrailProps{
		TlsDetails: &TlsDetails{
			TlsVersion: []*string{
				jsii.String("TLSv1.3"),
			},
		},
		EventMetadata: &AWSEventMetadataProps{
			Region: []*string{
				jsii.String("us-east-1"),
			},
		},
	}),
	Targets: []IRuleTarget{
		targets.NewLambdaFunction(fn),
	},
})

// Also works with L1 CfnRule
// Also works with L1 CfnRule
events.NewCfnRule(scope, jsii.String("CfnRule"), &CfnRuleProps{
	State: jsii.String("ENABLED"),
	EventPattern: awscdkmixinspreview.AWSAPICallViaCloudTrail_*EventPattern(&AWSAPICallViaCloudTrailProps{
		TlsDetails: &TlsDetails{
			TlsVersion: []*string{
				jsii.String("TLSv1.3"),
			},
		},
		EventMetadata: &AWSEventMetadataProps{
			Region: []*string{
				jsii.String("us-east-1"),
			},
		},
	}),
	Targets: []interface{}{
		&TargetProperty{
			Arn: fn.functionArn,
			Id: jsii.String("L1"),
		},
	},
})

Event Pattern Features

import { AWSAPICallViaCloudTrail } from '@aws-cdk/mixins-preview/aws-s3/events';

// Matches CloudTrail API calls across ALL S3 buckets
const pattern = AWSAPICallViaCloudTrail.eventPattern();

from aws_cdk.mixins_preview.aws_s3.events import AWSAPICallViaCloudTrail


# Matches CloudTrail API calls across ALL S3 buckets
pattern = AWSAPICallViaCloudTrail.event_pattern()

import software.amazon.awscdk.mixins.preview.services.s3.events.AWSAPICallViaCloudTrail;


// Matches CloudTrail API calls across ALL S3 buckets
EventPattern pattern = AWSAPICallViaCloudTrail.eventPattern();

using Amazon.CDK.Mixins.Preview.AWS.S3.Events;


// Matches CloudTrail API calls across ALL S3 buckets
var pattern = AWSAPICallViaCloudTrail.EventPattern();

import "github.com/aws/aws-cdk-go/awscdkmixinspreview"


// Matches CloudTrail API calls across ALL S3 buckets
pattern := awscdkmixinspreview.AWSAPICallViaCloudTrail_EventPattern()

Event Metadata Support: Control EventBridge pattern metadata

import { AWSAPICallViaCloudTrail } from '@aws-cdk/mixins-preview/aws-s3/events';
import * as events from 'aws-cdk-lib/aws-events';

const pattern = AWSAPICallViaCloudTrail.eventPattern({
  eventMetadata: {
    region: events.Match.prefix('us-'),
    version: ['0']
  }
});

from aws_cdk import AWSEventMetadataProps
from aws_cdk.mixins_preview.aws_s3.events import AWSAPICallViaCloudTrail
import aws_cdk.aws_events as events


pattern = AWSAPICallViaCloudTrail.event_pattern(
    event_metadata=AWSEventMetadataProps(
        region=events.Match.prefix("us-"),
        version=["0"]
    )
)

import software.amazon.awscdk.mixins.preview.services.s3.events.AWSAPICallViaCloudTrail;
import software.amazon.awscdk.services.events.*;


EventPattern pattern = AWSAPICallViaCloudTrail.eventPattern(AWSAPICallViaCloudTrailProps.builder()
        .eventMetadata(AWSEventMetadataProps.builder()
                .region(Match.prefix("us-"))
                .version(List.of("0"))
                .build())
        .build());

using Amazon.CDK.Mixins.Preview.AWS.S3.Events;
using Amazon.CDK.AWS.Events;


var pattern = AWSAPICallViaCloudTrail.EventPattern(new AWSAPICallViaCloudTrailProps {
    EventMetadata = new AWSEventMetadataProps {
        Region = Match.Prefix("us-"),
        Version = new [] { "0" }
    }
});

import "github.com/aws/aws-cdk-go/awscdkmixinspreview"
import events "github.com/aws/aws-cdk-go/awscdk"


pattern := awscdkmixinspreview.AWSAPICallViaCloudTrail_EventPattern(&AWSAPICallViaCloudTrailProps{
	EventMetadata: &AWSEventMetadataProps{
		Region: events.Match_Prefix(jsii.String("us-")),
		Version: []*string{
			jsii.String("0"),
		},
	},
})

Available Events

Event patterns are generated for EventBridge events available in the AWS Event Schema Registry. Common examples:

S3 Events:

• ObjectCreated.eventPattern() - Object creation events
• ObjectDeleted.eventPattern() - Object deletion events
• ObjectTagsAdded.eventPattern() - Object tagging events
• AWSAPICallViaCloudTrail.eventPattern() - CloudTrail API calls

Import events from service-specific modules:

// Resource-specific (filters to a specific bucket)
import { BucketEvents } from '@aws-cdk/mixins-preview/aws-s3/events';

// Standalone (matches across all buckets)
import { AWSAPICallViaCloudTrail, ObjectCreated, ObjectDeleted } from '@aws-cdk/mixins-preview/aws-s3/events';

# Resource-specific (filters to a specific bucket)
from aws_cdk.mixins_preview.aws_s3.events import BucketEvents

# Standalone (matches across all buckets)
from aws_cdk.mixins_preview.aws_s3.events import AWSAPICallViaCloudTrail, ObjectCreated, ObjectDeleted

// Resource-specific (filters to a specific bucket)
import software.amazon.awscdk.mixins.preview.services.s3.events.BucketEvents;

// Standalone (matches across all buckets)
import software.amazon.awscdk.mixins.preview.services.s3.events.AWSAPICallViaCloudTrail;
import software.amazon.awscdk.mixins.preview.services.s3.events.ObjectCreated;
import software.amazon.awscdk.mixins.preview.services.s3.events.ObjectDeleted;

// Resource-specific (filters to a specific bucket)
using Amazon.CDK.Mixins.Preview.AWS.S3.Events;

// Resource-specific (filters to a specific bucket)
import "github.com/aws/aws-cdk-go/awscdkmixinspreview"

// Standalone (matches across all buckets)
import "github.com/aws/aws-cdk-go/awscdkmixinspreview"

Submodules

• aws_bedrock.mixins
• aws_bedrockagentcore.mixins
• aws_cloudfront.mixins
• aws_devopsagent.mixins
• aws_ec2.mixins
• aws_ecs.mixins
• aws_eks.mixins
• aws_elasticloadbalancingv2.mixins
• aws_elementalinference.mixins
• aws_entityresolution.mixins
• aws_events.mixins
• aws_gamelift.mixins
• aws_logs
• aws_mediapackagev2.mixins
• aws_mediatailor.mixins
• aws_networkfirewall.mixins
• aws_pcs.mixins
• aws_qbusiness.mixins
• aws_rtbfabric.mixins
• aws_s3.mixins
• aws_securityhub.mixins
• aws_ses.mixins
• aws_shield.mixins
• aws_wisdom.mixins

Types

Name	Kind	Summary