@gradientedge/cdk-utils 8.90.0 → 8.92.0

package/src/lib/services/aws/elasticache/types.ts

@@ -1,13 +1,9 @@
 import { CfnCacheClusterProps, CfnReplicationGroupProps } from 'aws-cdk-lib/aws-elasticache'
 
 /**
- * @category cdk-utils.elasticache-manager
- * @category Compute
  */
 export interface ElastiCacheProps extends CfnCacheClusterProps {}
 
 /**
- * @category cdk-utils.elasticache-manager
- * @category Compute
  */
 export interface ReplicatedElastiCacheProps extends CfnReplicationGroupProps {}

package/src/lib/services/aws/eventbridge/main.ts

@@ -11,9 +11,6 @@ import { CommonConstruct } from '../../../common'
 import { EventBusProps, EventRuleProps, RuleProps, SqsToSfnPipeProps } from './types'
 
 /**
- * @stability stable
- * @category cdk-utils.event-manager
- * @subcategory Construct
  * @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.
@@ -27,15 +24,14 @@ import { EventBusProps, EventRuleProps, RuleProps, SqsToSfnPipeProps } from './t
  *     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 {string} id scoped id of the resource
-   * @param {CommonConstruct} scope scope in which this resource is defined
-   * @param {EventBusProps} props event bus properties
+   * @param id scoped id of the resource
+   * @param scope scope in which this resource is defined
+   * @param props event bus properties
    */
   public createEventBus(id: string, scope: CommonConstruct, props: EventBusProps) {
     if (!props) throw `EventBus props undefined for ${id}`
@@ -52,11 +48,11 @@ export class EventManager {
 
   /**
    * Method to create an event rule
-   * @param {string} id scoped id of the resource
-   * @param {CommonConstruct} scope scope in which this resource is defined
-   * @param {EventRuleProps} props event rule properties
-   * @param {events.IEventBus?} eventBus optional custom event bus
-   * @param {events.IRuleTarget[]?} targets optional event targets
+   * @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
    */
   public createRule(
     id: string,
@@ -68,11 +64,11 @@ export class EventManager {
     if (!props) throw `EventRule props undefined for ${id}`
 
     const rule = new events.Rule(scope, `${id}`, {
-      eventBus: eventBus,
       description: props.description,
-      ruleName: `${props.ruleName}-${scope.props.stage}`,
-      eventPattern: props.eventPattern,
       enabled: props.enabled,
+      eventBus: eventBus,
+      eventPattern: props.eventPattern,
+      ruleName: `${props.ruleName}-${scope.props.stage}`,
       schedule: props.schedule,
     })
 
@@ -96,13 +92,13 @@ export class EventManager {
 
   /**
    * @summary Method to create an eventbridge rule with lambda target
-   * @param {string} id scoped id of the resource
-   * @param {CommonConstruct} scope scope in which this resource is defined
-   * @param {RuleProps} props
-   * @param {lambda.Function} lambdaFunction
-   * @param {string} eventBusName
-   * @param {any} eventPattern
-   * @param {string} scheduleExpression
+   * @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
    */
   public createLambdaRule(
     id: string,
@@ -119,8 +115,8 @@ export class EventManager {
       description: 'Rule to send notification to lambda function target',
       eventBusName: eventBusName,
       eventPattern: eventPattern,
-      scheduleExpression: scheduleExpression,
       name: `${props.name}-${scope.props.stage}`,
+      scheduleExpression: scheduleExpression,
       state: props.state,
       targets: [
         {
@@ -146,14 +142,14 @@ export class EventManager {
 
   /**
    * @summary Method to create an eventbridge rule with fargate task target
-   * @param {string} id scoped id of the resource
-   * @param {CommonConstruct} scope scope in which this resource is defined
-   * @param {EventRuleProps} props
-   * @param {ecs.ICluster} cluster
-   * @param {ecs.ITaskDefinition} task
-   * @param {string[]} subnetIds
-   * @param {iam.Role | iam.CfnRole} role
-   * @param {any} eventPattern
+   * @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
    */
   public createFargateTaskRule(
     id: string,
@@ -175,7 +171,6 @@ export class EventManager {
       targets: [
         {
           arn: cluster.clusterArn,
-          id: `${id}-${scope.props.stage}`,
           ecsParameters: {
             launchType: 'FARGATE',
             networkConfiguration: {
@@ -184,6 +179,7 @@ export class EventManager {
             taskCount: 1,
             taskDefinitionArn: task.taskDefinitionArn,
           },
+          id: `${id}-${scope.props.stage}`,
           roleArn: role instanceof iam.Role ? role.roleArn : role.attrArn,
         },
       ],
@@ -197,8 +193,8 @@ export class EventManager {
 
   /**
    * @summary Method to create an eventbridge pipe with sqs queue as source and step function as target
-   * @param {string} id scoped id of the resource
-   * @param {CommonConstruct} scope scope in which this resource is defined
+   * @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
@@ -219,8 +215,11 @@ export class EventManager {
 
     const pipe = new pipes.CfnPipe(scope, `${id}`, {
       ...props,
-      name: `${props.name}-${scope.props.stage}`,
       description: props.description,
+      enrichment: props.enrichment,
+      enrichmentParameters: props.enrichmentParameters,
+      name: `${props.name}-${scope.props.stage}`,
+      roleArn: pipeRole.roleArn,
       source: sourceQueue.queueArn,
       sourceParameters: {
         filterCriteria: props.pipeFilterPattern
@@ -244,9 +243,6 @@ export class EventManager {
           invocationType: props.sfnInvocationType ?? 'FIRE_AND_FORGET',
         },
       },
-      enrichment: props.enrichment,
-      enrichmentParameters: props.enrichmentParameters,
-      roleArn: pipeRole.roleArn,
     })
 
     utils.createCfnOutput(`${id}-pipeArn`, scope, pipe.attrArn)

package/src/lib/services/aws/eventbridge/target.ts

@@ -5,9 +5,6 @@ import * as logs from 'aws-cdk-lib/aws-logs'
 import { CommonConstruct } from '../../../common'
 
 /**
- * @stability stable
- * @category cdk-utils.event-taeget-manager
- * @subcategory Construct
  * @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.
@@ -21,17 +18,16 @@ import { CommonConstruct } from '../../../common'
  *     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 {string} id scoped id of the resource
-   * @param {CommonConstruct} scope scope in which this resource is defined
-   * @param {logs.ILogGroup} logGroup the log group
-   * @param {LogGroupNoPolicyProps} props the log group target properties
+   * @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
    */
   public createCloudWatchLogGroupNoPolicy(
     id: string,
@@ -51,7 +47,6 @@ export interface LogGroupNoPolicyProps extends targets.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?: events.RuleTargetInput
@@ -65,6 +60,8 @@ export class CloudWatchLogGroupNoPolicy implements events.IRuleTarget {
 
   /**
    * Returns a RuleTarget that can be used to log an event into a CloudWatch LogGroup
+   * @param _rule
+   * @param _id
    */
   public bind(_rule: events.IRule, _id?: string): events.RuleTargetConfig {
     const logGroupStack = cdk.Stack.of(this.logGroup)
@@ -72,10 +69,10 @@ export class CloudWatchLogGroupNoPolicy implements events.IRuleTarget {
     return {
       ...targets.bindBaseTargetConfig(this.props),
       arn: logGroupStack.formatArn({
-        service: 'logs',
-        resource: 'log-group',
         arnFormat: cdk.ArnFormat.COLON_RESOURCE_NAME,
+        resource: 'log-group',
         resourceName: this.logGroup.logGroupName,
+        service: 'logs',
       }),
       input: this.props.event,
       targetResource: this.logGroup,

package/src/lib/services/aws/eventbridge/types.ts

@@ -4,35 +4,27 @@ import { TagProps } from '../../../types'
 
 /**
  }
- * @category cdk-utils.event-manager
- * @subcategory Properties
  */
 export interface SqsToSfnPipeProps extends CfnPipeProps {
   pipeFilterPattern?: any
+  sfnInputTemplate?: string
+  sfnInvocationType?: string
   sqsBatchSize?: number
   sqsMaximumBatchingWindowInSeconds?: number
-  sfnInvocationType?: string
-  sfnInputTemplate?: string
 }
 
 /**
- * @category cdk-utils.event-manager
- * @subcategory Properties
  */
 export interface EventRuleProps extends EBRuleProps {
   tags?: TagProps[]
 }
 
 /**
- * @category cdk-utils.event-manager
- * @subcategory Properties
  */
 export interface RuleProps extends CfnRuleProps {
   input?: string
 }
 
 /**
- * @category cdk-utils.event-manager
- * @subcategory Properties
  */
 export interface EventBusProps extends EBProps {}

package/src/lib/services/aws/evidently/main.ts

@@ -10,9 +10,6 @@ import {
 } from './types'
 
 /**
- * @stability stable
- * @category cdk-utils.evidently-manager
- * @subcategory Construct
  * @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.
@@ -26,21 +23,20 @@ import {
  *     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 {string} id scoped id of the resource
-   * @param {CommonConstruct} scope scope in which this resource is defined
-   * @param {EvidentlyProjectProps} props the project properties
+   * @param id scoped id of the resource
+   * @param scope scope in which this resource is defined
+   * @param props the project properties
    */
   public createProject(id: string, scope: CommonConstruct, props: EvidentlyProjectProps) {
     const project = new evidently.CfnProject(scope, `${id}`, {
       ...props,
-      name: `${props.name}-${scope.props.stage}`,
       description: `${props.description} ${scope.props.stage}`,
+      name: `${props.name}-${scope.props.stage}`,
     })
     utils.createCfnOutput(`${id}-projectArn`, scope, project.attrArn)
     utils.createCfnOutput(`${id}-projectName`, scope, project.name)
@@ -49,9 +45,9 @@ export class EvidentlyManager {
 
   /**
    * @summary Method to create a feature
-   * @param {string} id scoped id of the resource
-   * @param {CommonConstruct} scope scope in which this resource is defined
-   * @param {EvidentlyFeatureProps} props the feature properties
+   * @param id scoped id of the resource
+   * @param scope scope in which this resource is defined
+   * @param props the feature properties
    */
   public createFeature(id: string, scope: CommonConstruct, props: EvidentlyFeatureProps) {
     const feature = new evidently.CfnFeature(scope, `${id}`, props)
@@ -62,15 +58,15 @@ export class EvidentlyManager {
 
   /**
    * @summary Method to create a launch
-   * @param {string} id scoped id of the resource
-   * @param {CommonConstruct} scope scope in which this resource is defined
-   * @param {EvidentlyLaunchProps} props the launch properties
+   * @param id scoped id of the resource
+   * @param scope scope in which this resource is defined
+   * @param props the launch properties
    */
   public createLaunch(id: string, scope: CommonConstruct, props: EvidentlyLaunchProps) {
     const launch = new evidently.CfnLaunch(scope, `${id}`, {
       ...props,
-      name: `${props.name}-${scope.props.stage}`,
       description: `${props.description} ${scope.props.stage}`,
+      name: `${props.name}-${scope.props.stage}`,
     })
     utils.createCfnOutput(`${id}-launchArn`, scope, launch.attrArn)
     utils.createCfnOutput(`${id}-launchName`, scope, launch.name)
@@ -79,15 +75,15 @@ export class EvidentlyManager {
 
   /**
    * @summary Method to create an experiment
-   * @param {string} id scoped id of the resource
-   * @param {CommonConstruct} scope scope in which this resource is defined
-   * @param {EvidentlyExperimentProps} props the experiment properties
+   * @param id scoped id of the resource
+   * @param scope scope in which this resource is defined
+   * @param props the experiment properties
    */
   public createExperiment(id: string, scope: CommonConstruct, props: EvidentlyExperimentProps) {
     const experiment = new evidently.CfnExperiment(scope, `${id}`, {
       ...props,
-      name: `${props.name}-${scope.props.stage}`,
       description: `${props.description} ${scope.props.stage}`,
+      name: `${props.name}-${scope.props.stage}`,
     })
     utils.createCfnOutput(`${id}-experimentArn`, scope, experiment.attrArn)
     utils.createCfnOutput(`${id}-experimentName`, scope, experiment.name)
@@ -96,15 +92,15 @@ export class EvidentlyManager {
 
   /**
    * @summary Method to create a segment
-   * @param {string} id scoped id of the resource
-   * @param {CommonConstruct} scope scope in which this resource is defined
-   * @param {EvidentlySegmentProps} props the segment properties
+   * @param id scoped id of the resource
+   * @param scope scope in which this resource is defined
+   * @param props the segment properties
    */
   public createSegment(id: string, scope: CommonConstruct, props: EvidentlySegmentProps) {
     const segment = new evidently.CfnSegment(scope, `${id}`, {
       ...props,
-      name: `${props.name}-${scope.props.stage}`,
       description: `${props.description} ${scope.props.stage}`,
+      name: `${props.name}-${scope.props.stage}`,
     })
     utils.createCfnOutput(`${id}-segmentArn`, scope, segment.attrArn)
     utils.createCfnOutput(`${id}-segmentName`, scope, segment.name)

package/src/lib/services/aws/evidently/types.ts

@@ -7,31 +7,21 @@ import {
 } from 'aws-cdk-lib/aws-evidently'
 
 /**
- * @category cdk-utils.evidently-manager
- * @subcategory Properties
  */
 export interface EvidentlyProjectProps extends CfnProjectProps {}
 
 /**
- * @category cdk-utils.evidently-manager
- * @subcategory Properties
  */
 export interface EvidentlyFeatureProps extends CfnFeatureProps {}
 
 /**
- * @category cdk-utils.evidently-manager
- * @subcategory Properties
  */
 export interface EvidentlyLaunchProps extends CfnLaunchProps {}
 
 /**
- * @category cdk-utils.evidently-manager
- * @subcategory Properties
  */
 export interface EvidentlyExperimentProps extends CfnExperimentProps {}
 
 /**
- * @category cdk-utils.evidently-manager
- * @subcategory Properties
  */
 export interface EvidentlySegmentProps extends CfnSegmentProps {}