@gradientedge/cdk-utils-aws 1.0.0

package/dist/src/services/eventbridge/main.js

@@ -0,0 +1,295 @@
+import { Tags } from 'aws-cdk-lib';
+import { CfnRule, EventBus, Rule } from 'aws-cdk-lib/aws-events';
+import { Role } from 'aws-cdk-lib/aws-iam';
+import { CfnPermission } from 'aws-cdk-lib/aws-lambda';
+import { CfnPipe } from 'aws-cdk-lib/aws-pipes';
+import _ from 'lodash';
+import { createCfnOutput } from '../../utils/index.js';
+/**
+ * @classdesc Provides operations on AWS EventBridge.
+ * - A new instance of this class is injected into {@link CommonConstruct} constructor.
+ * - If a custom construct extends {@link CommonConstruct}, an instance is available within the context.
+ * @example
+ * import { CommonConstruct } from '@gradientedge/cdk-utils'
+ *
+ * class CustomConstruct extends CommonConstruct {
+ *   constructor(parent: Construct, id: string, props: common.CommonStackProps) {
+ *     super(parent, id, props)
+ *     this.props = props
+ *     this.eventManager.createLambdaRule('MyLambdaRule', this, lambdaFunction)
+ *   }
+ * }
+ * @see [CDK EventBridge Module]{@link https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_events-readme.html}
+ */
+export class EventManager {
+    /**
+     * Method to create an event bus
+     * @param id scoped id of the resource
+     * @param scope scope in which this resource is defined
+     * @param props event bus properties
+     */
+    createEventBus(id, scope, props) {
+        if (!props)
+            throw `EventBus props undefined for ${id}`;
+        if (!props.eventBusName)
+            throw `EventBus eventBusName undefined for ${id}`;
+        let eventBusName = props.eventBusName;
+        if (eventBusName != 'default') {
+            eventBusName = scope.resourceNameFormatter.format(props.eventBusName, scope.props.resourceNameOptions?.eventbridgeBus);
+        }
+        const eventBus = new EventBus(scope, `${id}`, {
+            ...props,
+            eventBusName,
+        });
+        createCfnOutput(`${id}-eventBusName`, scope, eventBusName);
+        createCfnOutput(`${id}-eventBusArn`, scope, eventBus.eventBusArn);
+        return eventBus;
+    }
+    /**
+     * Method to create an event rule
+     * @param id scoped id of the resource
+     * @param scope scope in which this resource is defined
+     * @param props event rule properties
+     * @param eventBus optional custom event bus
+     * @param targets optional event targets
+     */
+    createRule(id, scope, props, eventBus, targets) {
+        if (!props)
+            throw `EventRule props undefined for ${id}`;
+        if (!props.ruleName)
+            throw `EventRule ruleName undefined for ${id}`;
+        const rule = new Rule(scope, `${id}`, {
+            ...props,
+            eventBus,
+            ruleName: scope.resourceNameFormatter.format(props.ruleName, scope.props.resourceNameOptions?.eventbridgeRule),
+        });
+        if (targets && !_.isEmpty(targets)) {
+            _.forEach(targets, target => {
+                rule.addTarget(target);
+            });
+        }
+        if (props.tags && !_.isEmpty(props.tags)) {
+            _.forEach(props.tags, tag => {
+                Tags.of(rule).add(tag.key, tag.value);
+            });
+        }
+        createCfnOutput(`${id}-ruleArn`, scope, rule.ruleArn);
+        createCfnOutput(`${id}-ruleName`, scope, rule.ruleName);
+        return rule;
+    }
+    /**
+     * @summary Method to create an eventbridge rule with lambda target
+     * @param id scoped id of the resource
+     * @param scope scope in which this resource is defined
+     * @param props
+     * @param lambdaFunction
+     * @param eventBusName
+     * @param eventPattern
+     * @param scheduleExpression
+     */
+    createLambdaRule(id, scope, props, lambdaFunction, eventBusName, eventPattern, scheduleExpression) {
+        if (!props)
+            throw `EventRule props undefined for ${id}`;
+        if (!props.name)
+            throw `EventRule name undefined for ${id}`;
+        const eventRule = new CfnRule(scope, `${id}`, {
+            ...props,
+            description: 'Rule to send notification to lambda function target',
+            eventBusName,
+            eventPattern,
+            name: scope.resourceNameFormatter.format(props.name, scope.props.resourceNameOptions?.eventbridgeRule),
+            scheduleExpression,
+            targets: [
+                {
+                    arn: lambdaFunction.functionArn,
+                    id: scope.resourceNameFormatter.format(props.name, scope.props.resourceNameOptions?.eventbridgeRule),
+                    input: props.input ?? undefined,
+                },
+            ],
+        });
+        if (props.tags && !_.isEmpty(props.tags)) {
+            _.forEach(props.tags, tag => {
+                Tags.of(eventRule).add(tag.key, tag.value);
+            });
+        }
+        new CfnPermission(scope, `${id}LambdaPermission`, {
+            action: 'lambda:InvokeFunction',
+            functionName: lambdaFunction.functionName,
+            principal: 'events.amazonaws.com',
+            sourceArn: eventRule.attrArn,
+        });
+        createCfnOutput(`${id}-ruleArn`, scope, eventRule.attrArn);
+        createCfnOutput(`${id}-ruleName`, scope, eventRule.name);
+        return eventRule;
+    }
+    /**
+     * @summary Method to create an eventbridge rule with fargate task target
+     * @param id scoped id of the resource
+     * @param scope scope in which this resource is defined
+     * @param props
+     * @param cluster
+     * @param task
+     * @param subnetIds
+     * @param role
+     * @param eventPattern
+     */
+    createFargateTaskRule(id, scope, props, cluster, task, subnetIds, role, eventPattern) {
+        if (!props)
+            throw `EventRule props undefined for ${id}`;
+        if (!props.name)
+            throw `EventRule name undefined for ${id}`;
+        const eventRule = new CfnRule(scope, `${id}`, {
+            ...props,
+            description: 'Rule to send notification on new objects in data bucket to ecs task target',
+            eventPattern,
+            name: scope.resourceNameFormatter.format(props.name, scope.props.resourceNameOptions?.eventbridgeRule),
+            targets: [
+                {
+                    arn: cluster.clusterArn,
+                    ecsParameters: {
+                        launchType: 'FARGATE',
+                        networkConfiguration: {
+                            awsVpcConfiguration: { assignPublicIp: 'ENABLED', subnets: subnetIds },
+                        },
+                        taskCount: 1,
+                        taskDefinitionArn: task.taskDefinitionArn,
+                    },
+                    id: scope.resourceNameFormatter.format(props.name, scope.props.resourceNameOptions?.eventbridgeRule),
+                    roleArn: role instanceof Role ? role.roleArn : role.attrArn,
+                },
+            ],
+        });
+        createCfnOutput(`${id}-ruleArn`, scope, eventRule.attrArn);
+        createCfnOutput(`${id}-ruleName`, scope, eventRule.name);
+        return eventRule;
+    }
+    /**
+     * @summary Method to create an eventbridge pipe with sqs queue as source and step function as target
+     * @param id scoped id of the resource
+     * @param scope scope in which this resource is defined
+     * @param props the props for the pipe
+     * @param sourceQueue the source sqs queue
+     * @param targetStepFunction the target step function
+     */
+    createSqsToSfnCfnPipe(id, scope, props, sourceQueue, targetStepFunction) {
+        if (!props)
+            throw `Pipe props undefined for ${id}`;
+        if (!props.name)
+            throw `Pipe name undefined for ${id}`;
+        const pipeRole = scope.iamManager.createRoleForSqsToSfnPipe(`${id}-role`, scope, sourceQueue.queueArn, targetStepFunction.stateMachineArn);
+        const pipe = new CfnPipe(scope, `${id}`, {
+            ...props,
+            name: scope.resourceNameFormatter.format(props.name, scope.props.resourceNameOptions?.eventbridgePipe),
+            roleArn: pipeRole.roleArn,
+            source: sourceQueue.queueArn,
+            sourceParameters: {
+                filterCriteria: props.pipeFilterPattern
+                    ? {
+                        filters: [
+                            {
+                                pattern: JSON.stringify(props.pipeFilterPattern),
+                            },
+                        ],
+                    }
+                    : undefined,
+                sqsQueueParameters: {
+                    batchSize: props.sqsBatchSize,
+                    maximumBatchingWindowInSeconds: props.sqsMaximumBatchingWindowInSeconds,
+                },
+            },
+            target: targetStepFunction.stateMachineArn,
+            targetParameters: {
+                inputTemplate: props.sfnInputTemplate,
+                stepFunctionStateMachineParameters: {
+                    invocationType: props.sfnInvocationType ?? 'FIRE_AND_FORGET',
+                },
+            },
+        });
+        createCfnOutput(`${id}-pipeArn`, scope, pipe.attrArn);
+        createCfnOutput(`${id}-pipeName`, scope, pipe.name);
+        return pipe;
+    }
+    /**
+     * @summary Method to create an eventbridge pipe with sqs queue as source and lambda function as target
+     * @param id scoped id of the resource
+     * @param scope scope in which this resource is defined
+     * @param props the props for the pipe
+     * @param sourceQueue the source sqs queue
+     * @param targetLambdaFunction the target lambda function
+     */
+    createSqsToLambdaCfnPipe(id, scope, props, sourceQueue, targetLambdaFunction) {
+        if (!props)
+            throw `Pipe props undefined for ${id}`;
+        if (!props.name)
+            throw `Pipe name undefined for ${id}`;
+        const pipeRole = scope.iamManager.createRoleForSqsToLambdaPipe(`${id}-role`, scope, sourceQueue.queueArn, targetLambdaFunction.functionArn);
+        const pipe = new CfnPipe(scope, `${id}`, {
+            ...props,
+            name: scope.resourceNameFormatter.format(props.name, scope.props.resourceNameOptions?.eventbridgePipe),
+            roleArn: pipeRole.roleArn,
+            source: sourceQueue.queueArn,
+            sourceParameters: {
+                filterCriteria: props.pipeFilterPattern
+                    ? {
+                        filters: [
+                            {
+                                pattern: JSON.stringify(props.pipeFilterPattern),
+                            },
+                        ],
+                    }
+                    : undefined,
+                sqsQueueParameters: {
+                    batchSize: props.sqsBatchSize,
+                    maximumBatchingWindowInSeconds: props.sqsMaximumBatchingWindowInSeconds,
+                },
+            },
+            target: targetLambdaFunction.functionArn,
+            targetParameters: {
+                inputTemplate: props.lambdaInputTemplate,
+            },
+        });
+        createCfnOutput(`${id}-pipeArn`, scope, pipe.attrArn);
+        createCfnOutput(`${id}-pipeName`, scope, pipe.name);
+        return pipe;
+    }
+    /**
+     * @summary Method to create an eventbridge pipe with DynamoDb stream as source and lambda function as target
+     * @param id scoped id of the resource
+     * @param scope scope in which this resource is defined
+     * @param props the props for the pipe
+     * @param dynamoDbStream the source dynamoDb stream
+     * @param targetLambdaFunction the target lambda function
+     */
+    createDynamoDbToLambdaCfnPipe(id, scope, props, sourceDynamoDbStreamArn, targetLambdaFunction) {
+        if (!props)
+            throw `Pipe props undefined for ${id}`;
+        if (!props.name)
+            throw `Pipe name undefined for ${id}`;
+        const pipeRole = scope.iamManager.createRoleForDynamoDbToLambdaPipe(`${id}-role`, scope, sourceDynamoDbStreamArn, targetLambdaFunction.functionArn);
+        const pipe = new CfnPipe(scope, `${id}`, {
+            ...props,
+            name: scope.resourceNameFormatter.format(props.name, scope.props.resourceNameOptions?.eventbridgePipe),
+            roleArn: pipeRole.roleArn,
+            source: sourceDynamoDbStreamArn,
+            sourceParameters: {
+                filterCriteria: props.pipeFilterPattern
+                    ? {
+                        filters: [
+                            {
+                                pattern: JSON.stringify(props.pipeFilterPattern),
+                            },
+                        ],
+                    }
+                    : undefined,
+                dynamoDbStreamParameters: {
+                    startingPosition: props.dynamoDbStartingPosition,
+                    batchSize: props.dynamoDbBatchSize,
+                },
+            },
+            target: targetLambdaFunction.functionArn,
+        });
+        createCfnOutput(`${id}-pipeArn`, scope, pipe.attrArn);
+        createCfnOutput(`${id}-pipeName`, scope, pipe.name);
+        return pipe;
+    }
+}

package/dist/src/services/eventbridge/target.d.ts

@@ -0,0 +1,57 @@
+import { IRule, IRuleTarget, RuleTargetConfig, RuleTargetInput } from 'aws-cdk-lib/aws-events';
+import { TargetBaseProps } from 'aws-cdk-lib/aws-events-targets';
+import { ILogGroup } from 'aws-cdk-lib/aws-logs';
+import { CommonConstruct } from '../../common/index.js';
+/**
+ * @classdesc Provides operations on AWS EventBridge Targets
+ * - A new instance of this class is injected into {@link CommonConstruct} constructor.
+ * - If a custom construct extends {@link CommonConstruct}, an instance is available within the context.
+ * @example
+ * import { CommonConstruct } from '@gradientedge/cdk-utils'
+ *
+ * class CustomConstruct extends CommonConstruct {
+ *   constructor(parent: cdk.Construct, id: string, props: common.CommonStackProps) {
+ *     super(parent, id, props)
+ *     this.props = props
+ *     this.eventTargetManager.createCloudWatchLogGroupNoPolicy('MyLogGrouptarget', this, myLogGroup)
+ *   }
+ * }
+ * @see [CDK EventBridge Target Module]{@link https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_events_targets-readme.html}
+ */
+export declare class EventTargetManager {
+    /**
+     * @summary Method to create a cloud watch log group target without a policy.
+     * - This method is created as a workaround for cdk issue - https://github.com/aws/aws-cdk/issues/17002
+     * @param id scoped id of the resource
+     * @param scope scope in which this resource is defined
+     * @param logGroup the log group
+     * @param props the log group target properties
+     */
+    createCloudWatchLogGroupNoPolicy(id: string, scope: CommonConstruct, logGroup: ILogGroup, props?: LogGroupNoPolicyProps): CloudWatchLogGroupNoPolicy;
+}
+/**
+ * Customize the CloudWatch LogGroup Event Target
+ */
+export interface LogGroupNoPolicyProps extends TargetBaseProps {
+    /**
+     * The event to send to the CloudWatch LogGroup
+     *
+     * This will be the event logged into the CloudWatch LogGroup
+     * @default - the entire EventBridge event
+     */
+    readonly event?: RuleTargetInput;
+}
+/**
+ * Use an AWS CloudWatch LogGroup as an event rule target, but don't apply a policy.
+ */
+export declare class CloudWatchLogGroupNoPolicy implements IRuleTarget {
+    private readonly logGroup;
+    private readonly props;
+    constructor(logGroup: ILogGroup, props?: LogGroupNoPolicyProps);
+    /**
+     * Returns a RuleTarget that can be used to log an event into a CloudWatch LogGroup
+     * @param _rule
+     * @param _id
+     */
+    bind(_rule: IRule, _id?: string): RuleTargetConfig;
+}

package/dist/src/services/eventbridge/target.js

@@ -0,0 +1,61 @@
+import { ArnFormat, Stack } from 'aws-cdk-lib';
+import { bindBaseTargetConfig } from 'aws-cdk-lib/aws-events-targets';
+/**
+ * @classdesc Provides operations on AWS EventBridge Targets
+ * - A new instance of this class is injected into {@link CommonConstruct} constructor.
+ * - If a custom construct extends {@link CommonConstruct}, an instance is available within the context.
+ * @example
+ * import { CommonConstruct } from '@gradientedge/cdk-utils'
+ *
+ * class CustomConstruct extends CommonConstruct {
+ *   constructor(parent: cdk.Construct, id: string, props: common.CommonStackProps) {
+ *     super(parent, id, props)
+ *     this.props = props
+ *     this.eventTargetManager.createCloudWatchLogGroupNoPolicy('MyLogGrouptarget', this, myLogGroup)
+ *   }
+ * }
+ * @see [CDK EventBridge Target Module]{@link https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_events_targets-readme.html}
+ */
+export class EventTargetManager {
+    /**
+     * @summary Method to create a cloud watch log group target without a policy.
+     * - This method is created as a workaround for cdk issue - https://github.com/aws/aws-cdk/issues/17002
+     * @param id scoped id of the resource
+     * @param scope scope in which this resource is defined
+     * @param logGroup the log group
+     * @param props the log group target properties
+     */
+    createCloudWatchLogGroupNoPolicy(id, scope, logGroup, props) {
+        return new CloudWatchLogGroupNoPolicy(logGroup, props);
+    }
+}
+/**
+ * Use an AWS CloudWatch LogGroup as an event rule target, but don't apply a policy.
+ */
+export class CloudWatchLogGroupNoPolicy {
+    logGroup;
+    props;
+    constructor(logGroup, props = {}) {
+        this.logGroup = logGroup;
+        this.props = props;
+    }
+    /**
+     * Returns a RuleTarget that can be used to log an event into a CloudWatch LogGroup
+     * @param _rule
+     * @param _id
+     */
+    bind(_rule, _id) {
+        const logGroupStack = Stack.of(this.logGroup);
+        return {
+            ...bindBaseTargetConfig(this.props),
+            arn: logGroupStack.formatArn({
+                arnFormat: ArnFormat.COLON_RESOURCE_NAME,
+                resource: 'log-group',
+                resourceName: this.logGroup.logGroupName,
+                service: 'logs',
+            }),
+            input: this.props.event,
+            targetResource: this.logGroup,
+        };
+    }
+}

package/dist/src/services/eventbridge/types.d.ts

@@ -0,0 +1,43 @@
+import { CfnRuleProps, EventBusProps as EBProps, RuleProps as EBRuleProps } from 'aws-cdk-lib/aws-events';
+import { CfnPipeProps } from 'aws-cdk-lib/aws-pipes';
+import { TagProps } from '../../types/index.js';
+/**
+ */
+export interface SqsToSfnPipeProps extends CfnPipeProps {
+    pipeFilterPattern?: any;
+    sfnInputTemplate?: string;
+    sfnInvocationType?: string;
+    sqsBatchSize?: number;
+    sqsMaximumBatchingWindowInSeconds?: number;
+}
+/**
+ */
+export interface SqsToLambdaPipeProps extends CfnPipeProps {
+    pipeFilterPattern?: any;
+    sqsBatchSize?: number;
+    lambdaInputTemplate?: string;
+    sqsMaximumBatchingWindowInSeconds?: number;
+}
+/**
+ */
+export interface EventRuleProps extends EBRuleProps {
+    tags?: TagProps[];
+}
+/**
+ */
+export interface RuleProps extends CfnRuleProps {
+    input?: string;
+    tags?: TagProps[];
+}
+/**
+ */
+export interface EventBusProps extends EBProps {
+}
+/**
+ }
+ */
+export interface DynamoDbToLambdaPipeProps extends CfnPipeProps {
+    pipeFilterPattern?: any;
+    dynamoDbBatchSize?: number;
+    dynamoDbStartingPosition: string;
+}

package/dist/src/services/eventbridge/types.js

@@ -0,0 +1 @@
+export {};

package/dist/src/services/evidently/index.d.ts

@@ -0,0 +1,2 @@
+export * from './main.js';
+export * from './types.js';

package/dist/src/services/evidently/index.js

@@ -0,0 +1,2 @@
+export * from './main.js';
+export * from './types.js';

package/dist/src/services/evidently/main.d.ts

@@ -0,0 +1,56 @@
+import { CfnExperiment, CfnFeature, CfnLaunch, CfnProject, CfnSegment } from 'aws-cdk-lib/aws-evidently';
+import { CommonConstruct } from '../../common/index.js';
+import { EvidentlyExperimentProps, EvidentlyFeatureProps, EvidentlyLaunchProps, EvidentlyProjectProps, EvidentlySegmentProps } from './types.js';
+/**
+ * @classdesc Provides operations on AWS Evidently
+ * - A new instance of this class is injected into {@link CommonConstruct} constructor.
+ * - If a custom construct extends {@link CommonConstruct}, an instance is available within the context.
+ * @example
+ * import { CommonConstruct } from '@gradientedge/cdk-utils'
+ *
+ * class CustomConstruct extends CommonConstruct {
+ *   constructor(parent: cdk.Construct, id: string, props: common.CommonStackProps) {
+ *     super(parent, id, props)
+ *     this.props = props
+ *     this.evidentlyManager.createProject('MyNewProhect', this, props)
+ *   }
+ * }
+ * @see [CDK Evidently Module]{@link https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_evidently-readme.html}
+ */
+export declare class EvidentlyManager {
+    /**
+     * @summary Method to create a project
+     * @param id scoped id of the resource
+     * @param scope scope in which this resource is defined
+     * @param props the project properties
+     */
+    createProject(id: string, scope: CommonConstruct, props: EvidentlyProjectProps): CfnProject;
+    /**
+     * @summary Method to create a feature
+     * @param id scoped id of the resource
+     * @param scope scope in which this resource is defined
+     * @param props the feature properties
+     */
+    createFeature(id: string, scope: CommonConstruct, props: EvidentlyFeatureProps): CfnFeature;
+    /**
+     * @summary Method to create a launch
+     * @param id scoped id of the resource
+     * @param scope scope in which this resource is defined
+     * @param props the launch properties
+     */
+    createLaunch(id: string, scope: CommonConstruct, props: EvidentlyLaunchProps): CfnLaunch;
+    /**
+     * @summary Method to create an experiment
+     * @param id scoped id of the resource
+     * @param scope scope in which this resource is defined
+     * @param props the experiment properties
+     */
+    createExperiment(id: string, scope: CommonConstruct, props: EvidentlyExperimentProps): CfnExperiment;
+    /**
+     * @summary Method to create a segment
+     * @param id scoped id of the resource
+     * @param scope scope in which this resource is defined
+     * @param props the segment properties
+     */
+    createSegment(id: string, scope: CommonConstruct, props: EvidentlySegmentProps): CfnSegment;
+}

package/dist/src/services/evidently/main.js

@@ -0,0 +1,114 @@
+import { CfnExperiment, CfnFeature, CfnLaunch, CfnProject, CfnSegment } from 'aws-cdk-lib/aws-evidently';
+import { createCfnOutput } from '../../utils/index.js';
+/**
+ * @classdesc Provides operations on AWS Evidently
+ * - A new instance of this class is injected into {@link CommonConstruct} constructor.
+ * - If a custom construct extends {@link CommonConstruct}, an instance is available within the context.
+ * @example
+ * import { CommonConstruct } from '@gradientedge/cdk-utils'
+ *
+ * class CustomConstruct extends CommonConstruct {
+ *   constructor(parent: cdk.Construct, id: string, props: common.CommonStackProps) {
+ *     super(parent, id, props)
+ *     this.props = props
+ *     this.evidentlyManager.createProject('MyNewProhect', this, props)
+ *   }
+ * }
+ * @see [CDK Evidently Module]{@link https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_evidently-readme.html}
+ */
+export class EvidentlyManager {
+    /**
+     * @summary Method to create a project
+     * @param id scoped id of the resource
+     * @param scope scope in which this resource is defined
+     * @param props the project properties
+     */
+    createProject(id, scope, props) {
+        if (!props)
+            throw `EvidentlyProject props undefined for ${id}`;
+        if (!props.name)
+            throw `EvidentlyProject name undefined for ${id}`;
+        const project = new CfnProject(scope, `${id}`, {
+            ...props,
+            description: `${props.description} ${scope.props.stage}`,
+            name: scope.resourceNameFormatter.format(props.name, scope.props.resourceNameOptions?.evidentlyProject),
+        });
+        createCfnOutput(`${id}-projectArn`, scope, project.attrArn);
+        createCfnOutput(`${id}-projectName`, scope, project.name);
+        return project;
+    }
+    /**
+     * @summary Method to create a feature
+     * @param id scoped id of the resource
+     * @param scope scope in which this resource is defined
+     * @param props the feature properties
+     */
+    createFeature(id, scope, props) {
+        if (!props)
+            throw `EvidentlyFeature props undefined for ${id}`;
+        const feature = new CfnFeature(scope, `${id}`, props);
+        createCfnOutput(`${id}-featureArn`, scope, feature.attrArn);
+        createCfnOutput(`${id}-featureName`, scope, feature.name);
+        return feature;
+    }
+    /**
+     * @summary Method to create a launch
+     * @param id scoped id of the resource
+     * @param scope scope in which this resource is defined
+     * @param props the launch properties
+     */
+    createLaunch(id, scope, props) {
+        if (!props)
+            throw `EvidentlyLaunch props undefined for ${id}`;
+        if (!props.name)
+            throw `EvidentlyLaunch name undefined for ${id}`;
+        const launch = new CfnLaunch(scope, `${id}`, {
+            ...props,
+            description: `${props.description} ${scope.props.stage}`,
+            name: scope.resourceNameFormatter.format(props.name, scope.props.resourceNameOptions?.evidentlyLaunch),
+        });
+        createCfnOutput(`${id}-launchArn`, scope, launch.attrArn);
+        createCfnOutput(`${id}-launchName`, scope, launch.name);
+        return launch;
+    }
+    /**
+     * @summary Method to create an experiment
+     * @param id scoped id of the resource
+     * @param scope scope in which this resource is defined
+     * @param props the experiment properties
+     */
+    createExperiment(id, scope, props) {
+        if (!props)
+            throw `EvidentlyExperiment props undefined for ${id}`;
+        if (!props.name)
+            throw `EvidentlyExperiment name undefined for ${id}`;
+        const experiment = new CfnExperiment(scope, `${id}`, {
+            ...props,
+            description: `${props.description} ${scope.props.stage}`,
+            name: scope.resourceNameFormatter.format(props.name, scope.props.resourceNameOptions?.evidentlyExperiment),
+        });
+        createCfnOutput(`${id}-experimentArn`, scope, experiment.attrArn);
+        createCfnOutput(`${id}-experimentName`, scope, experiment.name);
+        return experiment;
+    }
+    /**
+     * @summary Method to create a segment
+     * @param id scoped id of the resource
+     * @param scope scope in which this resource is defined
+     * @param props the segment properties
+     */
+    createSegment(id, scope, props) {
+        if (!props)
+            throw `EvidentlySegment props undefined for ${id}`;
+        if (!props.name)
+            throw `EvidentlySegment name undefined for ${id}`;
+        const segment = new CfnSegment(scope, `${id}`, {
+            ...props,
+            description: `${props.description} ${scope.props.stage}`,
+            name: scope.resourceNameFormatter.format(props.name, scope.props.resourceNameOptions?.evidentlySegment),
+        });
+        createCfnOutput(`${id}-segmentArn`, scope, segment.attrArn);
+        createCfnOutput(`${id}-segmentName`, scope, segment.name);
+        return segment;
+    }
+}

package/dist/src/services/evidently/types.d.ts

@@ -0,0 +1,21 @@
+import { CfnExperimentProps, CfnFeatureProps, CfnLaunchProps, CfnProjectProps, CfnSegmentProps } from 'aws-cdk-lib/aws-evidently';
+/**
+ */
+export interface EvidentlyProjectProps extends CfnProjectProps {
+}
+/**
+ */
+export interface EvidentlyFeatureProps extends CfnFeatureProps {
+}
+/**
+ */
+export interface EvidentlyLaunchProps extends CfnLaunchProps {
+}
+/**
+ */
+export interface EvidentlyExperimentProps extends CfnExperimentProps {
+}
+/**
+ */
+export interface EvidentlySegmentProps extends CfnSegmentProps {
+}

package/dist/src/services/evidently/types.js

@@ -0,0 +1 @@
+export {};

package/dist/src/services/identity-access-management/index.d.ts

@@ -0,0 +1 @@
+export * from './main.js';

package/dist/src/services/identity-access-management/index.js

@@ -0,0 +1 @@
+export * from './main.js';