@rio-cloud/cdk-v2-constructs 6.0.1 → 6.1.0

package/docs/index.md

@@ -0,0 +1,105 @@
+# RIO CDK Constructs
+
+This package contains CDK2 constructs for RIO teams.
+
+> NPM: `@rio-cloud/cdk-v2-constructs`
+
+## Bootstrapping of CDK project
+
+```
+$ npx cdk init --language typescript
+```
+
+## Installation
+
+```
+$ npm install --save @rio-cloud/cdk-v2-constructs
+```
+
+## See also
+
+ * [How to contribute](./CONTRIBUTION.md)
+ * [Changelog](./CHANGELOG.md)
+ * [brief API description](./API.md)
+
+## Internal documentation for library devs
+[Documentation](./developers-readme.md)
+
+## Constructs overview (Under construction...)
+
+### Watchful
+
+Watchful constructs help generate some default monitors based on the resouces defined in your stack. Eg - If your stack contains a lambda function and you configure watchful construct, then it will create out of box metric monitors for Throttling, Lambda error and Log error monitors. The ever growing list of resources that watchful creates monitors for as of today are:
+
+- Application load balancer
+- Cloudfront
+- Documentdb
+- Dynamodb
+- Fargate
+- Lambda
+- RDS
+
+Simply add the following to your CDK stack to get started.
+```
+  import * as rio from '@rio-cloud/cdk-v2-constructs';
+    ...
+    const dw = new rio.watchfulv2.Watchful(this, 'Watchful', {
+      serviceName,
+    });
+    dw.watchScope(this); // Generates alarms for all supported resources
+    ...
+```
+
+There are options to override some defaults too. Please be aware that the library is very opinionated and is written with the most general use cases in mind. It is necessary to keep the use of the library simple enough, which means that there is only limited flexibility regarding the configuration options. Having said that, feel free to reach out to team CLAID over slack #rio-platform-support in case of feature requests.
+
+The broad classification of the monitors created by watchful are
+- Log error monitors
+- Metrics Query monitors: Basically everything other than log error monitors
+
+For Metrics query monitors, you can configure the priority (defaults as 3). For log error monitors, you can configure priority, renotification interval and can configure if the auto close of the monitor is disabled.
+```
+    ...
+    const dw = new Watchful(stack, 'Watchful2', { 
+      logErrorMonitorConfig: {
+        disableAutoClose: true, 
+        renotifyInterval: 150,
+        priority: 4,
+      },
+      queryErrorMonitorConfig: {
+        priority: 4
+      }
+    });
+    dw.watchScope(stack);
+```
+
+There is an `overrideAlarmThreshold` method which can be used to override the default watchful thresholds. Please make sure to use the method before the `watchscope` function.
+Eg -
+```
+...
+const dw = new Watchful(stack, 'Watchful', {});
+dw.overrideAlarmThreshold({
+  monitoredResourceScope: lambdaA,
+  monitorType: MonitorType.ERRORS,
+  threshold: 5,
+});
+dw.watchScope(stack);
+```
+
+### ClassifyPipelineType
+
+The pipelines can be tagged with key 'pipeline_type' to the following values:
+
+* deploy: To tag the production pipeline releasing the application
+* branch: The branch pipeline. Mostly used to test contributions / renovate updates
+* vulnerability: The vulnerability pipeline
+
+The construct `ClassifyPipelineType` can be used to tag the pipeline accordingly. This tag is also picked up by the Datadog pipeline metric used to monitor the pipelines. It is added as a tag to the metric. This gives you more flexibility with managing the monitors also. E.g. some teams don't want to get alerted for branch pipelines. You can then leverage this metric tag to filter the pipelines.
+
+Example:
+
+```typescript
+const pipeline = new pipelines.CodePipeline(this, 'Pipeline', {
+      ...
+    });
+rio.ClassifyPipelineType.apply(pipeline, rio.RioPipelineType.DEPLOY);
+```

package/lib/kafka/kafka-topic.d.ts

@@ -177,6 +177,13 @@ export interface KafkaTopicV4Props {
      * @defaultValue undefined
      */
     readonly logCompactionProperties?: LogCompactionProperties;
+    /**
+     * Specify whether the topic should be backed up automatically or not.
+     * It could just be enabled, if the topic is compacted and the RecoveryPolicy is 'recoverable'.
+     *
+     * @defaultValue undefined
+     */
+    readonly managedBackupEnabled?: boolean;
 }
 /**
  * The Topics target audience

package/lib/kafka/kafka-topic.js

@@ -43,9 +43,11 @@ class KafkaTopicV4 extends constructs_1.Construct {
                 Version: '4',
                 Audience: props.metadata.audience,
                 RecoveryPolicy: props.metadata.recoveryPolicy,
+                ManagedBackupEnabled: props.managedBackupEnabled,
             },
         });
         this.node.addValidation(validator(props));
+        this.node.addValidation(backupPropertiesValidator(props));
     }
 }
 exports.KafkaTopicV4 = KafkaTopicV4;
@@ -75,6 +77,20 @@ const validator = (props) => {
         },
     };
 };
+const backupPropertiesValidator = (props) => {
+    return {
+        validate: () => {
+            const result = [];
+            if (props.managedBackupEnabled && !props.isLogCompacted) {
+                result.push('Invalid [managedBackupEnabled]: managed backup can only be enabled for log compacted topics.');
+            }
+            if (props.managedBackupEnabled && props.metadata.recoveryPolicy !== 'recoverable') {
+                result.push('Invalid [managedBackupEnabled]: topics with managedBackupEnabled have to have recovery policy "recoverable".');
+            }
+            return result;
+        },
+    };
+};
 const mapProperties = (scope, props) => {
     const teamEmail = rio_landing_zone_1.RioLandingZone.getTeamEmailParameter(scope).stringValue;
     const events = props.metadata.events.map(source => {
@@ -107,4 +123,4 @@ const mapProperties = (scope, props) => {
         },
     };
 };
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"kafka-topic.js","sourceRoot":"","sources":["../../src/kafka/kafka-topic.ts"],"names":[],"mappings":"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","sourcesContent":["import { Duration, CfnResource, Annotations } from 'aws-cdk-lib';\nimport * as cdk from 'aws-cdk-lib';\nimport { Construct, IConstruct } from 'constructs';\nimport { KafkaEventSpec, KafkaEventSpecSource } from './kafka-event-spec';\nimport { RioLandingZone } from '../rio-landing-zone';\n\n/**\n * Wrapper for all meta data of a topic.\n */\nexport interface KafkaTopicMetaData {\n  /**\n   * The event specs of the events on that topic\n   */\n  readonly events: KafkaEventSpecSource[];\n\n  /**\n   * Describes the intent of the topic. This might be information about the events on that topic\n   * or additional information about the producer and the context of the events.\n   */\n  readonly description: string;\n}\n\n/**\n * Wrapper for all meta data of a v4 topic spec.\n */\nexport interface KafkaTopicMetaDataV4 {\n  /**\n   * The event specs of the events on that topic\n   */\n  readonly events: KafkaEventSpecSource[];\n\n  /**\n   * Describes the intent of the topic. This might be information about the events on that topic\n   * or additional information about the producer and the context of the events.\n   */\n  readonly description: string;\n\n  /**\n   * Indicates if a topic is meant for component internal usage only or if other services could\n   * use it too.\n   */\n  readonly audience: TopicAudience;\n\n  /**\n   * Indicates if the producer will restore the data in case of a disaster or not.\n   */\n  readonly recoveryPolicy: TopicRecoveryPolicy;\n}\n\n/**\n * Read and write permissions for the topic.\n *\n * strings are matched against the CNAME of the certificate of the Kafka clients.\n */\nexport interface KafkaAclStatement {\n  /**\n  * List of clients that should get write permissions\n  */\n  readonly write: string[];\n\n  /**\n   * List of clients that should get read permissions\n   */\n  readonly read: string[];\n\n  /**\n   * List of clients that should get delete permissions.\n   *\n   * Attention: Only use Deletion policy if you know what you are doing!\n   * This is only necessary for KStream and allows the application to delete messages and the topic.<br>\n   * If you just want to \"delete\" a message on a log compacted topic, you should not set this permission and send a tombstone message instead.\n   */\n  readonly delete?: string[];\n}\n\n/**\n * Wrapper for all log compaction related properties.\n */\nexport interface LogCompactionProperties {\n  /**\n   * The amount of time to retain delete tombstone markers for log compacted topics;\n   * The soft limit is 10 days but can be increased upon requests.\n   * @defaultValue 1 day\n   */\n  readonly deleteRetention?: Duration;\n}\n\n/**\n * The current service limits can be found in the topic limits configuration of the topic manager.\n *\n * @see https://collaboration.msi.audi.com/stash/projects/RSEVTBU/repos/topic-manager/browse/config/topic-service-limits.yaml\n */\nexport interface KafkaTopicProps {\n  /**\n   * The unique name of the topic; has to match pattern [A-Za-z0-9.-]+\n   */\n  readonly name: string;\n\n  /**\n   * Defines degree of parallelism of the topic; should be increased for\n   * large expected loads (e.g., 25 for rio.asset-iot-events).\n   * The soft limit is 10 partitions but can be increased upon requests.\n   */\n  readonly numberOfPartitions: number;\n\n  /**\n   * Defines degree of replication of messages; has to be between 1 and the number of brokers (currently 3).\n   * @defaultValue 3\n   */\n  readonly replicationFactor?: number;\n\n  /**\n   * Time how long messages are retained on Kafka cluster;\n   *\n   * We recommend 30 days for general events and 7 days for sensor events and other high-load cases.\n   * The soft limit is 3 to 30 days but can be increased upon requests.\n   * @defaultValue 7 days\n   */\n  readonly retention?: Duration;\n\n  /**\n   * If set to 'false, the topic's data will be deleted on Kafka 10 days after stack deletion.\n   * If set to 'true', it will be deleted immediately after stack deletion.\n   * @defaultValue false\n   */\n  readonly instantDeletionEnabled?: boolean;\n\n  /**\n   * The metadata of the topic.\n   */\n  readonly metadata: KafkaTopicMetaData;\n\n  /**\n   * The permissions to access to the topic's data.\n   */\n  readonly acl: KafkaAclStatement;\n\n  /**\n   * Specify whether the topic is log compacted or not.\n   */\n  readonly isLogCompacted: boolean;\n\n  /**\n   * Must only be provided if 'isLogCompacted' is 'true'.\n   * @defaultValue undefined\n   */\n  readonly logCompactionProperties?: LogCompactionProperties;\n}\n\n/**\n * The current service limits can be found in the topic limits configuration of the topic manager.\n *\n * @see https://collaboration.msi.audi.com/stash/projects/RSEVTBU/repos/topic-manager/browse/config/topic-service-limits.yaml\n */\nexport interface KafkaTopicV4Props {\n  /**\n   * The unique name of the topic; has to match pattern [A-Za-z0-9.-]+\n   */\n  readonly name: string;\n\n  /**\n   * Defines degree of parallelism of the topic; should be increased for\n   * large expected loads (e.g., 25 for rio.asset-iot-events).\n   * The soft limit is 10 partitions but can be increased upon requests.\n   */\n  readonly numberOfPartitions: number;\n\n  /**\n   * Defines degree of replication of messages; has to be between 1 and the number of brokers (currently 3).\n   * @defaultValue 3\n   */\n  readonly replicationFactor?: number;\n\n  /**\n   * Time how long messages are retained on Kafka cluster;\n   *\n   * We recommend 30 days for general events and 7 days for sensor events and other high-load cases.\n   * The soft limit is 3 to 30 days but can be increased upon requests.\n   * @defaultValue 7 days\n   */\n  readonly retention?: Duration;\n\n  /**\n   * If set to 'false, the topic's data will be deleted on Kafka 10 days after stack deletion.\n   * If set to 'true', it will be deleted immediately after stack deletion.\n   * @defaultValue false\n   */\n  readonly instantDeletionEnabled?: boolean;\n\n  /**\n   * The metadata of the topic.\n   */\n  readonly metadata: KafkaTopicMetaDataV4;\n\n  /**\n   * The permissions to access to the topic's data.\n   */\n  readonly acl: KafkaAclStatement;\n\n  /**\n   * Specify whether the topic is log compacted or not.\n   */\n  readonly isLogCompacted: boolean;\n\n  /**\n   * Must only be provided if 'isLogCompacted' is 'true'.\n   * @defaultValue undefined\n   */\n  readonly logCompactionProperties?: LogCompactionProperties;\n}\n\n/**\n * The Topics target audience\n */\nexport type TopicAudience = 'component-internal' | 'company-internal';\n\n/**\n * The Topics recovery policy guaranteed by the producer\n */\nexport type TopicRecoveryPolicy = 'none' | 'recoverable';\n\n/**\n * Construct to create a kafka topic.\n *\n * @deprecated use {@link KafkaTopicV4} instead\n */\nexport class KafkaTopic extends Construct {\n\n  constructor(scope: Construct, id: string, props: KafkaTopicProps) {\n    super(scope, id);\n\n\n    Annotations.of(this).addDeprecation('KafkaTopic', \"Use 'KafkaTopicV4'!\");\n\n    new CfnResource(this, 'KafkaTopic', {\n      type: 'Custom::KafkaTopic',\n      properties: {\n        ...mapProperties(this, props),\n        Version: '3',\n      },\n    });\n\n    this.node.addValidation(validator(props));\n  }\n}\n\n/**\n * Construct to create a kafka topic.\n */\nexport class KafkaTopicV4 extends Construct {\n\n  constructor(scope: Construct, id: string, props: KafkaTopicV4Props) {\n    super(scope, id);\n\n    new CfnResource(this, 'KafkaTopic', {\n      type: 'Custom::KafkaTopic',\n      properties: {\n        ...mapProperties(this, props),\n        Version: '4',\n        Audience: props.metadata.audience,\n        RecoveryPolicy: props.metadata.recoveryPolicy,\n      },\n    });\n\n    this.node.addValidation(validator(props));\n  }\n}\n\nconst validator = (props: KafkaTopicProps) => {\n  return {\n    validate: (): string[] => {\n      const result = [];\n\n      if (!props.name.match(/^[A-Za-z0-9.-]+$/)) {\n        result.push('Invalid [name]: expecting topic name to match the reg exp `[A-Za-z0-9.-]+`.');\n      }\n\n      if (!Number.isInteger(props.numberOfPartitions) || props.numberOfPartitions < 1) {\n        result.push(`Invalid [numberOfPartitions]: expecting number of partitions to be a positive integer but got ${props.numberOfPartitions}.`);\n      }\n\n      if (props.replicationFactor !== undefined &&\n          (!Number.isInteger(props.replicationFactor) || props.replicationFactor < 1 || props.replicationFactor > 3)) {\n        result.push('Invalid [replicationFactor]: expecting an integer between 1 and 3.');\n      }\n\n      if (props.metadata.events.length === 0) {\n        result.push('Invalid [metadata]: expecting [events] to have at least on element.');\n      }\n\n      if (!props.isLogCompacted && props.logCompactionProperties) {\n        result.push('Invalid [logCompactionProperties]: log compaction is disabled so properties must be undefined.');\n      }\n\n      return result;\n    },\n  };\n};\n\nconst mapProperties = (scope: IConstruct, props: KafkaTopicProps | KafkaTopicV4Props) => {\n  const teamEmail = RioLandingZone.getTeamEmailParameter(scope).stringValue;\n\n  const events = props.metadata.events.map(source => {\n    new KafkaEventSpec(scope, `${source.eventName.replace(/\\./g, '_')}-EventSpec`, { source });\n    return source.eventName;\n  });\n\n  const deleteRetentionDuration = props.logCompactionProperties?.deleteRetention ?? Duration.days(7);\n  if (props.acl.delete != undefined && props.acl.delete.length > 0) {\n    const annotations = cdk.Annotations.of(cdk.Stack.of(scope));\n    annotations.addWarningV2(\n      `@rio-cloud/cdk-v2-constructs/kafka/kafka-topic/${props.name}/DeletionPolicy`,\n      `\n ❌ You have set \"delete\" permission for kafka-topic ${props.name}. You probably do not need this. Please use this only if you know what you are doing.\n`,\n    );\n  }\n  return {\n    ServiceToken: 'arn:aws:sns:eu-west-1:186993757734:dp-topic-manager-sns-topic',\n    TopicName: props.name,\n    Description: props.metadata.description,\n    Events: events,\n    NumberOfPartitions: props.numberOfPartitions,\n    ReplicationFactor: props.replicationFactor ?? 3,\n    RetentionMs: (props.retention ?? Duration.days(7)).toMilliseconds(),\n    DeleteRetentionMs: props.isLogCompacted ? deleteRetentionDuration.toMilliseconds() : undefined,\n    InstantDeletionEnabled: props.instantDeletionEnabled ?? false,\n    CleanupPolicy: props.isLogCompacted ? 'compact' : 'delete',\n    TeamEmail: teamEmail,\n    ACL: {\n      Read: props.acl.read,\n      Write: props.acl.write,\n      Delete: props.acl.delete,\n    },\n  };\n};"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"kafka-topic.js","sourceRoot":"","sources":["../../src/kafka/kafka-topic.ts"],"names":[],"mappings":"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","sourcesContent":["import { Duration, CfnResource, Annotations } from 'aws-cdk-lib';\nimport * as cdk from 'aws-cdk-lib';\nimport { Construct, IConstruct } from 'constructs';\nimport { KafkaEventSpec, KafkaEventSpecSource } from './kafka-event-spec';\nimport { RioLandingZone } from '../rio-landing-zone';\n\n/**\n * Wrapper for all meta data of a topic.\n */\nexport interface KafkaTopicMetaData {\n  /**\n   * The event specs of the events on that topic\n   */\n  readonly events: KafkaEventSpecSource[];\n\n  /**\n   * Describes the intent of the topic. This might be information about the events on that topic\n   * or additional information about the producer and the context of the events.\n   */\n  readonly description: string;\n}\n\n/**\n * Wrapper for all meta data of a v4 topic spec.\n */\nexport interface KafkaTopicMetaDataV4 {\n  /**\n   * The event specs of the events on that topic\n   */\n  readonly events: KafkaEventSpecSource[];\n\n  /**\n   * Describes the intent of the topic. This might be information about the events on that topic\n   * or additional information about the producer and the context of the events.\n   */\n  readonly description: string;\n\n  /**\n   * Indicates if a topic is meant for component internal usage only or if other services could\n   * use it too.\n   */\n  readonly audience: TopicAudience;\n\n  /**\n   * Indicates if the producer will restore the data in case of a disaster or not.\n   */\n  readonly recoveryPolicy: TopicRecoveryPolicy;\n}\n\n/**\n * Read and write permissions for the topic.\n *\n * strings are matched against the CNAME of the certificate of the Kafka clients.\n */\nexport interface KafkaAclStatement {\n  /**\n  * List of clients that should get write permissions\n  */\n  readonly write: string[];\n\n  /**\n   * List of clients that should get read permissions\n   */\n  readonly read: string[];\n\n  /**\n   * List of clients that should get delete permissions.\n   *\n   * Attention: Only use Deletion policy if you know what you are doing!\n   * This is only necessary for KStream and allows the application to delete messages and the topic.<br>\n   * If you just want to \"delete\" a message on a log compacted topic, you should not set this permission and send a tombstone message instead.\n   */\n  readonly delete?: string[];\n}\n\n/**\n * Wrapper for all log compaction related properties.\n */\nexport interface LogCompactionProperties {\n  /**\n   * The amount of time to retain delete tombstone markers for log compacted topics;\n   * The soft limit is 10 days but can be increased upon requests.\n   * @defaultValue 1 day\n   */\n  readonly deleteRetention?: Duration;\n}\n\n/**\n * The current service limits can be found in the topic limits configuration of the topic manager.\n *\n * @see https://collaboration.msi.audi.com/stash/projects/RSEVTBU/repos/topic-manager/browse/config/topic-service-limits.yaml\n */\nexport interface KafkaTopicProps {\n  /**\n   * The unique name of the topic; has to match pattern [A-Za-z0-9.-]+\n   */\n  readonly name: string;\n\n  /**\n   * Defines degree of parallelism of the topic; should be increased for\n   * large expected loads (e.g., 25 for rio.asset-iot-events).\n   * The soft limit is 10 partitions but can be increased upon requests.\n   */\n  readonly numberOfPartitions: number;\n\n  /**\n   * Defines degree of replication of messages; has to be between 1 and the number of brokers (currently 3).\n   * @defaultValue 3\n   */\n  readonly replicationFactor?: number;\n\n  /**\n   * Time how long messages are retained on Kafka cluster;\n   *\n   * We recommend 30 days for general events and 7 days for sensor events and other high-load cases.\n   * The soft limit is 3 to 30 days but can be increased upon requests.\n   * @defaultValue 7 days\n   */\n  readonly retention?: Duration;\n\n  /**\n   * If set to 'false, the topic's data will be deleted on Kafka 10 days after stack deletion.\n   * If set to 'true', it will be deleted immediately after stack deletion.\n   * @defaultValue false\n   */\n  readonly instantDeletionEnabled?: boolean;\n\n  /**\n   * The metadata of the topic.\n   */\n  readonly metadata: KafkaTopicMetaData;\n\n  /**\n   * The permissions to access to the topic's data.\n   */\n  readonly acl: KafkaAclStatement;\n\n  /**\n   * Specify whether the topic is log compacted or not.\n   */\n  readonly isLogCompacted: boolean;\n\n  /**\n   * Must only be provided if 'isLogCompacted' is 'true'.\n   * @defaultValue undefined\n   */\n  readonly logCompactionProperties?: LogCompactionProperties;\n}\n\n/**\n * The current service limits can be found in the topic limits configuration of the topic manager.\n *\n * @see https://collaboration.msi.audi.com/stash/projects/RSEVTBU/repos/topic-manager/browse/config/topic-service-limits.yaml\n */\nexport interface KafkaTopicV4Props {\n  /**\n   * The unique name of the topic; has to match pattern [A-Za-z0-9.-]+\n   */\n  readonly name: string;\n\n  /**\n   * Defines degree of parallelism of the topic; should be increased for\n   * large expected loads (e.g., 25 for rio.asset-iot-events).\n   * The soft limit is 10 partitions but can be increased upon requests.\n   */\n  readonly numberOfPartitions: number;\n\n  /**\n   * Defines degree of replication of messages; has to be between 1 and the number of brokers (currently 3).\n   * @defaultValue 3\n   */\n  readonly replicationFactor?: number;\n\n  /**\n   * Time how long messages are retained on Kafka cluster;\n   *\n   * We recommend 30 days for general events and 7 days for sensor events and other high-load cases.\n   * The soft limit is 3 to 30 days but can be increased upon requests.\n   * @defaultValue 7 days\n   */\n  readonly retention?: Duration;\n\n  /**\n   * If set to 'false, the topic's data will be deleted on Kafka 10 days after stack deletion.\n   * If set to 'true', it will be deleted immediately after stack deletion.\n   * @defaultValue false\n   */\n  readonly instantDeletionEnabled?: boolean;\n\n  /**\n   * The metadata of the topic.\n   */\n  readonly metadata: KafkaTopicMetaDataV4;\n\n  /**\n   * The permissions to access to the topic's data.\n   */\n  readonly acl: KafkaAclStatement;\n\n  /**\n   * Specify whether the topic is log compacted or not.\n   */\n  readonly isLogCompacted: boolean;\n\n  /**\n   * Must only be provided if 'isLogCompacted' is 'true'.\n   * @defaultValue undefined\n   */\n  readonly logCompactionProperties?: LogCompactionProperties;\n\n  /**\n   * Specify whether the topic should be backed up automatically or not.\n   * It could just be enabled, if the topic is compacted and the RecoveryPolicy is 'recoverable'.\n   *\n   * @defaultValue undefined\n   */\n  readonly managedBackupEnabled?: boolean;\n}\n\n/**\n * The Topics target audience\n */\nexport type TopicAudience = 'component-internal' | 'company-internal';\n\n/**\n * The Topics recovery policy guaranteed by the producer\n */\nexport type TopicRecoveryPolicy = 'none' | 'recoverable';\n\n/**\n * Construct to create a kafka topic.\n *\n * @deprecated use {@link KafkaTopicV4} instead\n */\nexport class KafkaTopic extends Construct {\n\n  constructor(scope: Construct, id: string, props: KafkaTopicProps) {\n    super(scope, id);\n\n\n    Annotations.of(this).addDeprecation('KafkaTopic', \"Use 'KafkaTopicV4'!\");\n\n    new CfnResource(this, 'KafkaTopic', {\n      type: 'Custom::KafkaTopic',\n      properties: {\n        ...mapProperties(this, props),\n        Version: '3',\n      },\n    });\n\n    this.node.addValidation(validator(props));\n  }\n}\n\n/**\n * Construct to create a kafka topic.\n */\nexport class KafkaTopicV4 extends Construct {\n\n  constructor(scope: Construct, id: string, props: KafkaTopicV4Props) {\n    super(scope, id);\n\n    new CfnResource(this, 'KafkaTopic', {\n      type: 'Custom::KafkaTopic',\n      properties: {\n        ...mapProperties(this, props),\n        Version: '4',\n        Audience: props.metadata.audience,\n        RecoveryPolicy: props.metadata.recoveryPolicy,\n        ManagedBackupEnabled: props.managedBackupEnabled,\n      },\n    });\n\n    this.node.addValidation(validator(props));\n    this.node.addValidation(backupPropertiesValidator(props));\n  }\n}\n\nconst validator = (props: KafkaTopicProps) => {\n  return {\n    validate: (): string[] => {\n      const result = [];\n\n      if (!props.name.match(/^[A-Za-z0-9.-]+$/)) {\n        result.push('Invalid [name]: expecting topic name to match the reg exp `[A-Za-z0-9.-]+`.');\n      }\n\n      if (!Number.isInteger(props.numberOfPartitions) || props.numberOfPartitions < 1) {\n        result.push(`Invalid [numberOfPartitions]: expecting number of partitions to be a positive integer but got ${props.numberOfPartitions}.`);\n      }\n\n      if (props.replicationFactor !== undefined &&\n          (!Number.isInteger(props.replicationFactor) || props.replicationFactor < 1 || props.replicationFactor > 3)) {\n        result.push('Invalid [replicationFactor]: expecting an integer between 1 and 3.');\n      }\n\n      if (props.metadata.events.length === 0) {\n        result.push('Invalid [metadata]: expecting [events] to have at least on element.');\n      }\n\n      if (!props.isLogCompacted && props.logCompactionProperties) {\n        result.push('Invalid [logCompactionProperties]: log compaction is disabled so properties must be undefined.');\n      }\n\n      return result;\n    },\n  };\n};\n\nconst backupPropertiesValidator = (props: KafkaTopicV4Props) => {\n  return {\n    validate: (): string[] => {\n      const result = [];\n\n      if (props.managedBackupEnabled && !props.isLogCompacted) {\n        result.push('Invalid [managedBackupEnabled]: managed backup can only be enabled for log compacted topics.');\n      }\n\n      if (props.managedBackupEnabled && props.metadata.recoveryPolicy !== 'recoverable') {\n        result.push('Invalid [managedBackupEnabled]: topics with managedBackupEnabled have to have recovery policy \"recoverable\".');\n      }\n\n      return result;\n    },\n  };\n\n};\n\nconst mapProperties = (scope: IConstruct, props: KafkaTopicProps | KafkaTopicV4Props) => {\n  const teamEmail = RioLandingZone.getTeamEmailParameter(scope).stringValue;\n\n  const events = props.metadata.events.map(source => {\n    new KafkaEventSpec(scope, `${source.eventName.replace(/\\./g, '_')}-EventSpec`, { source });\n    return source.eventName;\n  });\n\n  const deleteRetentionDuration = props.logCompactionProperties?.deleteRetention ?? Duration.days(7);\n  if (props.acl.delete != undefined && props.acl.delete.length > 0) {\n    const annotations = cdk.Annotations.of(cdk.Stack.of(scope));\n    annotations.addWarningV2(\n      `@rio-cloud/cdk-v2-constructs/kafka/kafka-topic/${props.name}/DeletionPolicy`,\n      `\n ❌ You have set \"delete\" permission for kafka-topic ${props.name}. You probably do not need this. Please use this only if you know what you are doing.\n`,\n    );\n  }\n  return {\n    ServiceToken: 'arn:aws:sns:eu-west-1:186993757734:dp-topic-manager-sns-topic',\n    TopicName: props.name,\n    Description: props.metadata.description,\n    Events: events,\n    NumberOfPartitions: props.numberOfPartitions,\n    ReplicationFactor: props.replicationFactor ?? 3,\n    RetentionMs: (props.retention ?? Duration.days(7)).toMilliseconds(),\n    DeleteRetentionMs: props.isLogCompacted ? deleteRetentionDuration.toMilliseconds() : undefined,\n    InstantDeletionEnabled: props.instantDeletionEnabled ?? false,\n    CleanupPolicy: props.isLogCompacted ? 'compact' : 'delete',\n    TeamEmail: teamEmail,\n    ACL: {\n      Read: props.acl.read,\n      Write: props.acl.write,\n      Delete: props.acl.delete,\n    },\n  };\n};"]}

package/mkdocs.yaml

@@ -0,0 +1,12 @@
+site_name: 'RIO Kafka backup documentation'
+
+nav:
+  - "User Guide": index.md
+  - "Developer Guide": developers-readme.md
+  - "API Docs": API.md
+  - "Changelog": changelog.md
+  - "CDK v1 Migration Guide": migration_guide.md
+  - "Contribution": contribution.md
+
+plugins:
+  - techdocs-core

package/package.json

@@ -15,7 +15,7 @@
   ],
   "main": "lib/index.js",
   "license": "Apache-2.0",
-  "version": "6.0.1",
+  "version": "6.1.0",
   "types": "lib/index.d.ts",
   "stability": "stable",
   "exports": {
@@ -40,7 +40,7 @@
     "compareUrlFormat": "{{host}}/projects/RIODEV/repos/cdk-v2-constructs/compare/commits?targetBranch=refs%2Ftags%2F{{previousTag}}&sourceBranch=refs%2Ftags%2F{{currentTag}}",
     "issueUrlFormat": "https://jira.collaboration-man.com/browse/{{id}}",
     "scripts": {
-      "postbump": "git add API.md"
+      "postbump": "git add docs/API.md"
     }
   },
   "scripts": {
@@ -52,7 +52,7 @@
     "test": "jest --coverage",
     "test:watch": "jest --watch",
     "eslint": "eslint --ext .ts,.tsx --fix --no-error-on-unmatched-pattern src test",
-    "docgen": "jsii-docgen",
+    "docgen": "jsii-docgen -o ./docs/API.md",
     "cdk": "cdk",
     "release:check": "node release-commit-check.js",
     "release:build": "npm run build && npm run docgen && npm run bump",

package/version.json

@@ -1,3 +1,3 @@
 {
-  "version": "6.0.1"
+  "version": "6.1.0"
 }