@rio-cloud/cdk-v2-constructs 8.2.1 → 8.4.0-alpha.0

package/README.md

@@ -21,6 +21,7 @@ $ npm install --save @rio-cloud/cdk-v2-constructs
  * [How to contribute](./docs/contribution.md)
  * [Changelog](./docs/changelog.md)
  * [brief API description](./docs/API.md)
+ * [Agent documentation](./docs/AGENTS_DOCUMENTATION.md)
 
 ## Internal documentation for library devs
 [Documentation](./docs/developers-readme.md)

package/docs/AGENTS_DOCUMENTATION.md

@@ -0,0 +1,64 @@
+# Agents Documentation for `@rio-cloud/cdk-v2-constructs`
+
+## Purpose
+
+Use this document as the entry point when an agent needs to understand or apply the npm package `@rio-cloud/cdk-v2-constructs` from an installed project. Prefer package-owned documentation in `.d.ts` files and generated type artifacts over memory or guesses.
+
+This package provides RIO-specific AWS CDK v2 constructs and helpers for:
+
+- Watchful and Datadog monitoring for RIO-standard service alerting and observability
+- ECS/Fargate services as the paved road for running backend workloads on RIO
+- Kafka topics and event sources
+- Codified AWS account defaults such as VPC properties and well-known SSM parameters
+- Pipeline tagging and delivery monitoring
+- Backup policy helpers
+- SES observability
+
+## Reference Order
+
+After reaching this document, use these package artifacts as the primary references:
+
+1. Read this file first.
+2. Check the installed package's `package.json` exports before using any subpath import or package-local artifact.
+3. Read `README.md` for the package-level overview and `docs/AGENTS_RIO_INFRASTRUCTURE_GUIDE.md` for infrastructure-specific project structure, pipeline guardrails, or pipeline-oriented work.
+
+Use `lib/**/*.d.ts` for generated type information and JSDoc-derived annotations. When guidance in this document conflicts with generated package annotations such as `lib/**/*.d.ts`, or `.jsii`, trust the generated package annotations.
+
+## Import And Edit Workflow
+
+Prefer `import * as rio from '@rio-cloud/cdk-v2-constructs';` unless an exported subpath is explicitly available in the installed `package.json`.
+
+Read the relevant declaration comments and examples before writing or changing infrastructure code.
+
+## Usage Guidance
+
+### General
+
+Prefer RIO constructs over raw AWS CDK constructs when the use case matches. These constructs encode RIO infrastructure defaults, Datadog tags, shared secrets, team and account SSM parameters, and monitoring conventions.
+
+Do not set construct attributes explicitly when the value you plan to set is already the construct default. Prefer relying on defaults unless you are intentionally changing behavior and that intent is clear in the code.
+
+Preserve the target repository's existing stack boundaries and scripts when maintaining an existing project.
+
+### Observability
+
+Watchful is RIO's monitoring and alerting abstraction. Prefer `rio.watchfulv2.Watchful` and `rio.datadogv2`. Use legacy `watchful` or `datadog` only when maintaining existing code that already depends on those APIs.
+
+Do not add raw CloudWatch metrics, alarms, or monitoring resources for agent-generated changes. Use RIO monitoring constructs and Datadog-based abstractions for observability.
+
+Treat `rio.SesObservability` logs as PII. Do not forward those logs to third-party services and do not extend retention beyond the construct default.
+
+### RIO Infrastructure Defaults
+
+RIO infrastructure defaults are the baseline VPC, hosted zone, and team/account values provided by the RIO environment. Use `rio.RioLandingZone` helpers for default VPC, hosted zone, team name, team identifier, team email, team alert Slack channel, and account name. Avoid hard-coded VPC IDs, hosted-zone IDs, or parameter names when a helper exists.
+
+### Services
+
+Use `rio.RioFargateService` for ECS/Fargate services when possible.
+### Kafka
+
+Use `rio.KafkaTopicV4` for new Kafka topics. Set audience and recovery policy deliberately.
+
+### Backup And Delivery
+
+Use `rio.BackupPolicy`, `rio.ClassifyPipelineType`, and `rio.DeliveryPerformanceMonitoringOverride` for backup and pipeline metadata instead of manually adding equivalent tags. Branch pipelines validate contributions or Renovate updates; vulnerability pipelines run vulnerability-focused checks.

package/docs/AGENTS_RIO_INFRASTRUCTURE_GUIDE.md

@@ -0,0 +1,56 @@
+# RIO Infrastructure Guide
+
+Use this guide when consuming `@rio-cloud/cdk-v2-constructs` from RIO CDK v2
+infrastructure projects.
+
+This guide covers infrastructure-specific structure and pipeline conventions.
+
+## Recommended Structure
+
+A typical RIO infrastructure package often uses a structure like:
+
+- `bin/infrastructure.ts`: CDK app entrypoint and deployment environment.
+- `lib/app-stack.ts`: runtime service resources and service monitoring.
+- `lib/data-stack.ts`: stateful or shared data resources.
+- `lib/pipeline-stack.ts`: trigger bucket sources, CodePipeline definitions,
+  CodeBuild steps, deployment stages, and pipeline metadata.
+- `test/`: synthesized template assertions.
+
+## Infrastructure-Specific Usage
+
+Use `rio.ClassifyPipelineType.apply(...)` with `rio.RioPipelineType.DEPLOY`,
+`BRANCH`, or `VULNERABILITY` for pipeline metadata instead of manually
+recreating equivalent tags.
+
+Use `rio.TriggerKey.MASTER_REPO` and `rio.TriggerKey.BRANCH_REPO` for RIO
+Bitbucket trigger bucket keys. Standard RIO pipelines use the imported
+`bitbucket-integration-s3-bucket` trigger bucket and S3 source events.
+
+## Pipeline Guardrails
+
+Use the trigger bucket source pattern for standard RIO pipelines. Do not use
+CodeStar Connections, GitHub source actions, `CodeStarConnectionsSourceAction`,
+or `ConnectionArn` parameters unless the service intentionally needs a
+non-standard pipeline.
+
+Include the main deployment pipeline by default. Add branch and vulnerability
+pipelines only when the project needs them or the user requests them.
+
+Prefer the target project's current CodeBuild defaults for new pipeline code.
+Fall back to another architecture or build image only when the project
+toolchain requires it, and document that reason.
+
+## Project Setup
+
+When creating or extending a RIO infrastructure package, keep the project
+layout intentional and replace any placeholder service names, account IDs,
+build commands, and stack contents with project-specific values before
+synthesis.
+
+When using `node` or `npm` commands for this package, read the project's
+`.nvmrc` or `package.json` to determine the expected Node.js version, and keep
+`npm` aligned with the versions declared there. Align local development, CI,
+and any generated pipeline steps with those project-specific settings.
+
+If a project already has infrastructure, preserve its stack boundaries and
+validation scripts unless the change explicitly updates them.

package/lib/backup/backup-policy.d.ts

@@ -10,6 +10,13 @@ export declare enum Criticality {
 /**
  * Helper function to tag constructs with correct backup values to be picked
  * up by the rio landing zone backup solution.
+ *
+ * Apply this to stateful resources that must be discovered by the RIO landing-zone backup solution.
+ *
+ * Example:
+ * ```ts
+ * BackupPolicy.apply(table, Criticality.HIGH);
+ * ```
  */
 export declare class BackupPolicy {
     static apply(target: IConstruct, criticality: Criticality): void;

package/lib/backup/backup-policy.js

@@ -16,6 +16,13 @@ var Criticality;
 /**
  * Helper function to tag constructs with correct backup values to be picked
  * up by the rio landing zone backup solution.
+ *
+ * Apply this to stateful resources that must be discovered by the RIO landing-zone backup solution.
+ *
+ * Example:
+ * ```ts
+ * BackupPolicy.apply(table, Criticality.HIGH);
+ * ```
  */
 class BackupPolicy {
     static apply(target, criticality) {
@@ -25,4 +32,4 @@ class BackupPolicy {
 exports.BackupPolicy = BackupPolicy;
 _a = JSII_RTTI_SYMBOL_1;
 BackupPolicy[_a] = { fqn: "@rio-cloud/cdk-v2-constructs.BackupPolicy", version: "0.0.0" };
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYmFja3VwLXBvbGljeS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9iYWNrdXAvYmFja3VwLXBvbGljeS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7OztBQUFBLDZDQUFtQztBQUduQzs7R0FFRztBQUNILElBQVksV0FJWDtBQUpELFdBQVksV0FBVztJQUNyQiwwQkFBVyxDQUFBO0lBQ1gsZ0NBQWlCLENBQUE7SUFDakIsNEJBQWEsQ0FBQTtBQUNmLENBQUMsRUFKVyxXQUFXLDJCQUFYLFdBQVcsUUFJdEI7QUFFRDs7O0dBR0c7QUFDSCxNQUFhLFlBQVk7SUFDdkIsTUFBTSxDQUFDLEtBQUssQ0FBQyxNQUFrQixFQUFFLFdBQXdCO1FBQ3ZELGtCQUFJLENBQUMsRUFBRSxDQUFDLE1BQU0sQ0FBQyxDQUFDLEdBQUcsQ0FBQyxpQ0FBaUMsRUFBRSxXQUFXLENBQUMsQ0FBQztJQUN0RSxDQUFDOztBQUhILG9DQUlDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgVGFncyB9IGZyb20gJ2F3cy1jZGstbGliJztcbmltcG9ydCB7IElDb25zdHJ1Y3QgfSBmcm9tICdjb25zdHJ1Y3RzJztcblxuLyoqXG4gKiBUaGUgYWxsb3dlZCB2YWx1ZXMgZm9yIGJhY2t1cCBjcml0aWNhbGl0eSBsZXZlbHNcbiAqL1xuZXhwb3J0IGVudW0gQ3JpdGljYWxpdHkge1xuICBMT1cgPSAnbG93JyxcbiAgTUVESVVNID0gJ21lZGl1bScsXG4gIEhJR0ggPSAnaGlnaCcsXG59XG5cbi8qKlxuICogSGVscGVyIGZ1bmN0aW9uIHRvIHRhZyBjb25zdHJ1Y3RzIHdpdGggY29ycmVjdCBiYWNrdXAgdmFsdWVzIHRvIGJlIHBpY2tlZFxuICogdXAgYnkgdGhlIHJpbyBsYW5kaW5nIHpvbmUgYmFja3VwIHNvbHV0aW9uLlxuICovXG5leHBvcnQgY2xhc3MgQmFja3VwUG9saWN5IHtcbiAgc3RhdGljIGFwcGx5KHRhcmdldDogSUNvbnN0cnVjdCwgY3JpdGljYWxpdHk6IENyaXRpY2FsaXR5KSB7XG4gICAgVGFncy5vZih0YXJnZXQpLmFkZCgncmlvLWx6LWJhY2t1cC1jcml0aWNhbGl0eS1sZXZlbCcsIGNyaXRpY2FsaXR5KTtcbiAgfVxufVxuIl19
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYmFja3VwLXBvbGljeS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9iYWNrdXAvYmFja3VwLXBvbGljeS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7OztBQUFBLDZDQUFtQztBQUduQzs7R0FFRztBQUNILElBQVksV0FJWDtBQUpELFdBQVksV0FBVztJQUNyQiwwQkFBVyxDQUFBO0lBQ1gsZ0NBQWlCLENBQUE7SUFDakIsNEJBQWEsQ0FBQTtBQUNmLENBQUMsRUFKVyxXQUFXLDJCQUFYLFdBQVcsUUFJdEI7QUFFRDs7Ozs7Ozs7OztHQVVHO0FBQ0gsTUFBYSxZQUFZO0lBQ3ZCLE1BQU0sQ0FBQyxLQUFLLENBQUMsTUFBa0IsRUFBRSxXQUF3QjtRQUN2RCxrQkFBSSxDQUFDLEVBQUUsQ0FBQyxNQUFNLENBQUMsQ0FBQyxHQUFHLENBQUMsaUNBQWlDLEVBQUUsV0FBVyxDQUFDLENBQUM7SUFDdEUsQ0FBQzs7QUFISCxvQ0FJQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IFRhZ3MgfSBmcm9tICdhd3MtY2RrLWxpYic7XG5pbXBvcnQgeyBJQ29uc3RydWN0IH0gZnJvbSAnY29uc3RydWN0cyc7XG5cbi8qKlxuICogVGhlIGFsbG93ZWQgdmFsdWVzIGZvciBiYWNrdXAgY3JpdGljYWxpdHkgbGV2ZWxzXG4gKi9cbmV4cG9ydCBlbnVtIENyaXRpY2FsaXR5IHtcbiAgTE9XID0gJ2xvdycsXG4gIE1FRElVTSA9ICdtZWRpdW0nLFxuICBISUdIID0gJ2hpZ2gnLFxufVxuXG4vKipcbiAqIEhlbHBlciBmdW5jdGlvbiB0byB0YWcgY29uc3RydWN0cyB3aXRoIGNvcnJlY3QgYmFja3VwIHZhbHVlcyB0byBiZSBwaWNrZWRcbiAqIHVwIGJ5IHRoZSByaW8gbGFuZGluZyB6b25lIGJhY2t1cCBzb2x1dGlvbi5cbiAqXG4gKiBBcHBseSB0aGlzIHRvIHN0YXRlZnVsIHJlc291cmNlcyB0aGF0IG11c3QgYmUgZGlzY292ZXJlZCBieSB0aGUgUklPIGxhbmRpbmctem9uZSBiYWNrdXAgc29sdXRpb24uXG4gKlxuICogRXhhbXBsZTpcbiAqIGBgYHRzXG4gKiBCYWNrdXBQb2xpY3kuYXBwbHkodGFibGUsIENyaXRpY2FsaXR5LkhJR0gpO1xuICogYGBgXG4gKi9cbmV4cG9ydCBjbGFzcyBCYWNrdXBQb2xpY3kge1xuICBzdGF0aWMgYXBwbHkodGFyZ2V0OiBJQ29uc3RydWN0LCBjcml0aWNhbGl0eTogQ3JpdGljYWxpdHkpIHtcbiAgICBUYWdzLm9mKHRhcmdldCkuYWRkKCdyaW8tbHotYmFja3VwLWNyaXRpY2FsaXR5LWxldmVsJywgY3JpdGljYWxpdHkpO1xuICB9XG59XG4iXX0=

package/lib/contributions/team-shipper-inbound-blue/pipeline/code-build-project.d.ts

@@ -0,0 +1,64 @@
+import * as codebuild from 'aws-cdk-lib/aws-codebuild';
+import type * as ecr from 'aws-cdk-lib/aws-ecr';
+import type { Construct } from 'constructs';
+/**
+ * Properties for a CodeBuild project that is injected as a parallel CodePipeline action.
+ */
+export interface ParallelBuildProjectProps {
+    /**
+     * Path to the buildspec yaml file, resolved from the consuming CDK app's current working directory.
+     */
+    readonly buildSpecPath: string;
+    /**
+     * Name of the service.
+     */
+    readonly serviceName: string;
+    /**
+     * Name of the hosted zone.
+     */
+    readonly hostedZoneName: string;
+    /**
+     * Repository used by image build steps.
+     *
+     * When provided, its URI is exposed as `REPO_URI`.
+     */
+    readonly repo?: ecr.IRepository;
+    /**
+     * Action-level environment values used when calculating `projectConfigHash`.
+     */
+    readonly env?: Record<string, string>;
+    /**
+     * Caching strategy to use.
+     */
+    readonly cache?: codebuild.Cache;
+    /**
+     * Build image for the project.
+     *
+     * Defaults to the ARM Amazon Linux 2023 standard image used by WebEDI-style services.
+     */
+    readonly buildImage?: codebuild.IBuildImage;
+    /**
+     * Compute type for the project.
+     *
+     * Defaults to `BUILD_GENERAL1_LARGE`.
+     */
+    readonly computeType?: codebuild.ComputeType;
+    /**
+     * Additional project-level environment variables.
+     */
+    readonly additionalEnvironmentVariables?: Record<string, codebuild.BuildEnvironmentVariable>;
+}
+/**
+ * Converts action-level string environment values to CodeBuild action environment variables.
+ */
+export declare function getCodeBuildActionEnvironmentVariables(env?: Record<string, string>, projectConfigHash?: string): Record<string, codebuild.BuildEnvironmentVariable>;
+/**
+ * CodeBuild project for parallel pipeline build work.
+ */
+export declare class ParallelBuildProject extends codebuild.PipelineProject {
+    /**
+     * Hash of buildspec, project environment, and action-level environment inputs.
+     */
+    readonly projectConfigHash: string;
+    constructor(scope: Construct, id: string, props: ParallelBuildProjectProps);
+}

package/lib/contributions/team-shipper-inbound-blue/pipeline/code-build-project.js

@@ -0,0 +1,88 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ParallelBuildProject = void 0;
+exports.getCodeBuildActionEnvironmentVariables = getCodeBuildActionEnvironmentVariables;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const crypto = require("node:crypto");
+const fs = require("node:fs");
+const aws_cdk_lib_1 = require("aws-cdk-lib");
+const codebuild = require("aws-cdk-lib/aws-codebuild");
+const codepipeline = require("aws-cdk-lib/aws-codepipeline");
+const yaml = require("js-yaml");
+const DEFAULT_BUILD_IMAGE = codebuild.LinuxArmBuildImage.AMAZON_LINUX_2023_STANDARD_3_0;
+const DEFAULT_COMPUTE_TYPE = codebuild.ComputeType.LARGE;
+const RESERVED_ACTION_ENVIRONMENT_NAMES = ['PIPELINE_EXECUTION_ID', '_PROJECT_CONFIG_HASH'];
+function getProjectEnvironmentVariables(scope, props) {
+    const environmentVariables = {
+        AWS_ACCOUNT_ID: { value: aws_cdk_lib_1.Stack.of(scope).account },
+        SERVICE_NAME: { value: props.serviceName },
+        HOSTED_ZONE_NAME: { value: props.hostedZoneName },
+    };
+    if (props.repo?.repositoryUri) {
+        Object.assign(environmentVariables, { REPO_URI: { value: props.repo.repositoryUri } });
+    }
+    const additionalEnvironmentVariables = props.additionalEnvironmentVariables ?? {};
+    const overriddenStandardVariables = Object.keys(additionalEnvironmentVariables).filter(name => name in environmentVariables);
+    if (overriddenStandardVariables.length > 0) {
+        throw new Error(`additionalEnvironmentVariables must not override standard environment variables: ${overriddenStandardVariables.join(', ')}.`);
+    }
+    return {
+        ...environmentVariables,
+        ...additionalEnvironmentVariables,
+    };
+}
+function loadBuildSpec(buildSpecPath) {
+    const buildSpec = yaml.load(fs.readFileSync(buildSpecPath, { encoding: 'utf-8' }));
+    if (buildSpec === null || typeof buildSpec !== 'object' || Array.isArray(buildSpec)) {
+        throw new Error(`Buildspec at ${buildSpecPath} must contain a YAML object.`);
+    }
+    return buildSpec;
+}
+/**
+ * Converts action-level string environment values to CodeBuild action environment variables.
+ */
+function getCodeBuildActionEnvironmentVariables(env = {}, projectConfigHash) {
+    const overriddenReservedVariables = RESERVED_ACTION_ENVIRONMENT_NAMES.filter(name => name in env);
+    if (overriddenReservedVariables.length > 0) {
+        throw new Error(`Action environment variables must not override reserved variables: ${overriddenReservedVariables.join(', ')}.`);
+    }
+    return Object.fromEntries(Object.entries({
+        ...env,
+        PIPELINE_EXECUTION_ID: codepipeline.GlobalVariables.executionId,
+        ...(projectConfigHash ? { _PROJECT_CONFIG_HASH: projectConfigHash } : {}),
+    }).map(([name, value]) => [name, { value }]));
+}
+/**
+ * CodeBuild project for parallel pipeline build work.
+ */
+class ParallelBuildProject extends codebuild.PipelineProject {
+    constructor(scope, id, props) {
+        const buildSpec = loadBuildSpec(props.buildSpecPath);
+        const environmentVariables = getProjectEnvironmentVariables(scope, props);
+        const buildImage = props.buildImage ?? DEFAULT_BUILD_IMAGE;
+        const computeType = props.computeType ?? DEFAULT_COMPUTE_TYPE;
+        const environment = {
+            buildImage,
+            computeType,
+            environmentVariables,
+        };
+        super(scope, id, {
+            buildSpec: codebuild.BuildSpec.fromObject(buildSpec),
+            cache: props.cache,
+            environment,
+        });
+        this.projectConfigHash = crypto
+            .createHash('sha256')
+            .update(JSON.stringify(aws_cdk_lib_1.Stack.of(scope).resolve({
+            buildSpec,
+            projectEnvironment: environment,
+            actionEnvironment: props.env,
+        })))
+            .digest('hex');
+    }
+}
+exports.ParallelBuildProject = ParallelBuildProject;
+_a = JSII_RTTI_SYMBOL_1;
+ParallelBuildProject[_a] = { fqn: "@rio-cloud/cdk-v2-constructs.ParallelBuildProject", version: "0.0.0" };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"code-build-project.js","sourceRoot":"","sources":["../../../../src/contributions/team-shipper-inbound-blue/pipeline/code-build-project.ts"],"names":[],"mappings":"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","sourcesContent":["import * as crypto from 'node:crypto';\nimport * as fs from 'node:fs';\nimport { Stack } from 'aws-cdk-lib';\nimport * as codebuild from 'aws-cdk-lib/aws-codebuild';\nimport * as codepipeline from 'aws-cdk-lib/aws-codepipeline';\nimport type * as ecr from 'aws-cdk-lib/aws-ecr';\nimport type { Construct } from 'constructs';\nimport * as yaml from 'js-yaml';\n\nconst DEFAULT_BUILD_IMAGE = codebuild.LinuxArmBuildImage.AMAZON_LINUX_2023_STANDARD_3_0;\nconst DEFAULT_COMPUTE_TYPE = codebuild.ComputeType.LARGE;\nconst RESERVED_ACTION_ENVIRONMENT_NAMES = ['PIPELINE_EXECUTION_ID', '_PROJECT_CONFIG_HASH'];\n\n/**\n * Properties for a CodeBuild project that is injected as a parallel CodePipeline action.\n */\nexport interface ParallelBuildProjectProps {\n  /**\n   * Path to the buildspec yaml file, resolved from the consuming CDK app's current working directory.\n   */\n  readonly buildSpecPath: string;\n\n  /**\n   * Name of the service.\n   */\n  readonly serviceName: string;\n\n  /**\n   * Name of the hosted zone.\n   */\n  readonly hostedZoneName: string;\n\n  /**\n   * Repository used by image build steps.\n   *\n   * When provided, its URI is exposed as `REPO_URI`.\n   */\n  readonly repo?: ecr.IRepository;\n\n  /**\n   * Action-level environment values used when calculating `projectConfigHash`.\n   */\n  readonly env?: Record<string, string>;\n\n  /**\n   * Caching strategy to use.\n   */\n  readonly cache?: codebuild.Cache;\n\n  /**\n   * Build image for the project.\n   *\n   * Defaults to the ARM Amazon Linux 2023 standard image used by WebEDI-style services.\n   */\n  readonly buildImage?: codebuild.IBuildImage;\n\n  /**\n   * Compute type for the project.\n   *\n   * Defaults to `BUILD_GENERAL1_LARGE`.\n   */\n  readonly computeType?: codebuild.ComputeType;\n\n  /**\n   * Additional project-level environment variables.\n   */\n  readonly additionalEnvironmentVariables?: Record<string, codebuild.BuildEnvironmentVariable>;\n}\n\nfunction getProjectEnvironmentVariables(\n  scope: Construct,\n  props: ParallelBuildProjectProps\n): Record<string, codebuild.BuildEnvironmentVariable> {\n  const environmentVariables: Record<string, codebuild.BuildEnvironmentVariable> = {\n    AWS_ACCOUNT_ID: { value: Stack.of(scope).account },\n    SERVICE_NAME: { value: props.serviceName },\n    HOSTED_ZONE_NAME: { value: props.hostedZoneName },\n  };\n\n  if (props.repo?.repositoryUri) {\n    Object.assign(environmentVariables, { REPO_URI: { value: props.repo.repositoryUri } });\n  }\n\n  const additionalEnvironmentVariables = props.additionalEnvironmentVariables ?? {};\n  const overriddenStandardVariables = Object.keys(additionalEnvironmentVariables).filter(\n    name => name in environmentVariables\n  );\n  if (overriddenStandardVariables.length > 0) {\n    throw new Error(\n      `additionalEnvironmentVariables must not override standard environment variables: ${overriddenStandardVariables.join(', ')}.`\n    );\n  }\n\n  return {\n    ...environmentVariables,\n    ...additionalEnvironmentVariables,\n  };\n}\n\nfunction loadBuildSpec(buildSpecPath: string): Record<string, unknown> {\n  const buildSpec = yaml.load(fs.readFileSync(buildSpecPath, { encoding: 'utf-8' }));\n\n  if (buildSpec === null || typeof buildSpec !== 'object' || Array.isArray(buildSpec)) {\n    throw new Error(`Buildspec at ${buildSpecPath} must contain a YAML object.`);\n  }\n\n  return buildSpec as Record<string, unknown>;\n}\n\n/**\n * Converts action-level string environment values to CodeBuild action environment variables.\n */\nexport function getCodeBuildActionEnvironmentVariables(\n  env: Record<string, string> = {},\n  projectConfigHash?: string\n): Record<string, codebuild.BuildEnvironmentVariable> {\n  const overriddenReservedVariables = RESERVED_ACTION_ENVIRONMENT_NAMES.filter(name => name in env);\n  if (overriddenReservedVariables.length > 0) {\n    throw new Error(\n      `Action environment variables must not override reserved variables: ${overriddenReservedVariables.join(', ')}.`\n    );\n  }\n\n  return Object.fromEntries(\n    Object.entries({\n      ...env,\n      PIPELINE_EXECUTION_ID: codepipeline.GlobalVariables.executionId,\n      ...(projectConfigHash ? { _PROJECT_CONFIG_HASH: projectConfigHash } : {}),\n    }).map(([name, value]) => [name, { value }])\n  );\n}\n\n/**\n * CodeBuild project for parallel pipeline build work.\n */\nexport class ParallelBuildProject extends codebuild.PipelineProject {\n  /**\n   * Hash of buildspec, project environment, and action-level environment inputs.\n   */\n  readonly projectConfigHash: string;\n\n  constructor(scope: Construct, id: string, props: ParallelBuildProjectProps) {\n    const buildSpec = loadBuildSpec(props.buildSpecPath);\n    const environmentVariables = getProjectEnvironmentVariables(scope, props);\n    const buildImage = props.buildImage ?? DEFAULT_BUILD_IMAGE;\n    const computeType = props.computeType ?? DEFAULT_COMPUTE_TYPE;\n    const environment: codebuild.BuildEnvironment = {\n      buildImage,\n      computeType,\n      environmentVariables,\n    };\n\n    super(scope, id, {\n      buildSpec: codebuild.BuildSpec.fromObject(buildSpec),\n      cache: props.cache,\n      environment,\n    });\n\n    this.projectConfigHash = crypto\n      .createHash('sha256')\n      .update(\n        JSON.stringify(\n          Stack.of(scope).resolve({\n            buildSpec,\n            projectEnvironment: environment,\n            actionEnvironment: props.env,\n          })\n        )\n      )\n      .digest('hex');\n  }\n}\n"]}

package/lib/contributions/team-shipper-inbound-blue/pipeline/index.d.ts

@@ -0,0 +1,2 @@
+export * from './code-build-project';
+export * from './pipeline-build-stage-actions';

package/lib/contributions/team-shipper-inbound-blue/pipeline/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./code-build-project"), exports);
+__exportStar(require("./pipeline-build-stage-actions"), exports);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvY29udHJpYnV0aW9ucy90ZWFtLXNoaXBwZXItaW5ib3VuZC1ibHVlL3BpcGVsaW5lL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7Ozs7Ozs7QUFBQSx1REFBcUM7QUFDckMsaUVBQStDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9jb2RlLWJ1aWxkLXByb2plY3QnO1xuZXhwb3J0ICogZnJvbSAnLi9waXBlbGluZS1idWlsZC1zdGFnZS1hY3Rpb25zJztcbiJdfQ==

package/lib/contributions/team-shipper-inbound-blue/pipeline/pipeline-build-stage-actions.d.ts

@@ -0,0 +1,81 @@
+import * as codebuild from 'aws-cdk-lib/aws-codebuild';
+import * as codepipeline from 'aws-cdk-lib/aws-codepipeline';
+import * as codepipelineActions from 'aws-cdk-lib/aws-codepipeline-actions';
+import { Construct } from 'constructs';
+/**
+ * Properties for locating an existing generated CodePipeline action.
+ */
+export interface PipelineBuildStageActionsProps {
+    /**
+     * The underlying CodePipeline generated by `aws-cdk-lib/pipelines.CodePipeline`.
+     */
+    readonly pipeline: codepipeline.Pipeline;
+    /**
+     * Name of the action whose input artifact should be reused.
+     */
+    readonly actionName: string;
+}
+/**
+ * Properties for a CodeBuild action added by `PipelineBuildStageActions`.
+ */
+export interface PipelineBuildActionProps extends codepipeline.CommonAwsActionProps {
+    /**
+     * The list of additional input artifacts for this action.
+     */
+    readonly extraInputs?: codepipeline.Artifact[];
+    /**
+     * The list of output artifacts for this action.
+     */
+    readonly outputs?: codepipeline.Artifact[];
+    /**
+     * The action's CodeBuild project.
+     */
+    readonly project: codebuild.IProject;
+    /**
+     * The type of CodeBuild action.
+     *
+     * @default CodeBuildActionType.BUILD
+     */
+    readonly actionType?: codepipelineActions.CodeBuildActionType;
+    /**
+     * Environment variables to pass to the CodeBuild project when this action executes.
+     */
+    readonly environmentVariables?: Record<string, codebuild.BuildEnvironmentVariable>;
+    /**
+     * Whether to check for secrets in plaintext environment variables.
+     *
+     * @default true
+     */
+    readonly checkSecretsInPlainTextEnvVariables?: boolean;
+    /**
+     * Trigger a batch build.
+     *
+     * @default false
+     */
+    readonly executeBatchBuild?: boolean;
+    /**
+     * Combine build artifacts for batch builds.
+     *
+     * @default false
+     */
+    readonly combineBatchBuildArtifacts?: boolean;
+}
+/**
+ * Adds CodeBuild actions next to an existing action in the same pipeline stage.
+ */
+export declare class PipelineBuildStageActions extends Construct {
+    /**
+     * Stage that contains the located action.
+     */
+    readonly stage: codepipeline.IStage;
+    /**
+     * First input artifact of the located action.
+     */
+    readonly sourceArtifact: codepipeline.Artifact;
+    constructor(scope: Construct, id: string, props: PipelineBuildStageActionsProps);
+    /**
+     * Adds a CodeBuild action using the located action's first input artifact.
+     */
+    addBuildAction(props: PipelineBuildActionProps): void;
+    private findPipelineActionContext;
+}

package/lib/contributions/team-shipper-inbound-blue/pipeline/pipeline-build-stage-actions.js

@@ -0,0 +1,57 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PipelineBuildStageActions = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const codepipelineActions = require("aws-cdk-lib/aws-codepipeline-actions");
+const constructs_1 = require("constructs");
+const rio_claidometer_1 = require("../../../rio-claidometer");
+/**
+ * Adds CodeBuild actions next to an existing action in the same pipeline stage.
+ */
+class PipelineBuildStageActions extends constructs_1.Construct {
+    constructor(scope, id, props) {
+        super(scope, id);
+        const context = this.findPipelineActionContext(props.pipeline, props.actionName);
+        this.stage = context.stage;
+        this.sourceArtifact = context.sourceArtifact;
+        new rio_claidometer_1.Claidometer(this, 'Claidometer', {
+            product: rio_claidometer_1.ClaidometerProduct.CDK_CONTRIBUTION,
+            packageName: 'team-shipper-inbound-blue',
+            feature: 'pipeline',
+            version: '0.0.1',
+        });
+    }
+    /**
+     * Adds a CodeBuild action using the located action's first input artifact.
+     */
+    addBuildAction(props) {
+        const { actionType, ...actionProps } = props;
+        this.stage.addAction(new codepipelineActions.CodeBuildAction({
+            ...actionProps,
+            type: actionType,
+            input: this.sourceArtifact,
+        }));
+    }
+    findPipelineActionContext(pipeline, actionName) {
+        for (const stage of pipeline.stages) {
+            const action = stage.actions.find(candidate => candidate.actionProperties.actionName === actionName);
+            if (action === undefined) {
+                continue;
+            }
+            const sourceArtifact = action.actionProperties.inputs?.[0];
+            if (sourceArtifact === undefined) {
+                throw new Error(`Unable to locate the source artifact used by the ${actionName} action.`);
+            }
+            return {
+                stage,
+                sourceArtifact,
+            };
+        }
+        throw new Error(`Unable to locate the ${actionName} action in the generated pipeline.`);
+    }
+}
+exports.PipelineBuildStageActions = PipelineBuildStageActions;
+_a = JSII_RTTI_SYMBOL_1;
+PipelineBuildStageActions[_a] = { fqn: "@rio-cloud/cdk-v2-constructs.PipelineBuildStageActions", version: "0.0.0" };
+//# sourceMappingURL=data:application/json;base64,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

package/lib/datadogv2/datadog-slo.d.ts

@@ -61,6 +61,13 @@ export declare const DATADOG_SLO_TIMEFRAMES: readonly ["7d", "30d", "90d"];
 export type DatadogSloTimeframe = (typeof DATADOG_SLO_TIMEFRAMES)[number];
 /**
  * Generate default SLO thresholds for a given criticality level.
+ *
+ * Prefer this helper unless a specific target has been agreed for the service.
+ *
+ * Example:
+ * ```ts
+ * thresholds: defaultThresholds('medium')
+ * ```
  */
 export declare function defaultThresholds(level: CriticalityLevel): DatadogSloThreshold[];
 /**

package/lib/datadogv2/datadog-slo.js

@@ -10,6 +10,13 @@ const rio_landing_zone_1 = require("../rio-landing-zone");
 exports.DATADOG_SLO_TIMEFRAMES = ['7d', '30d', '90d'];
 /**
  * Generate default SLO thresholds for a given criticality level.
+ *
+ * Prefer this helper unless a specific target has been agreed for the service.
+ *
+ * Example:
+ * ```ts
+ * thresholds: defaultThresholds('medium')
+ * ```
  */
 function defaultThresholds(level) {
     // [Capabilities - RIO Tech Platform Docs - MAN Confluence PRD](https://confluence.collaboration-man.com/x/nLUSEw)
@@ -106,4 +113,4 @@ function validateCustomTags(customTags) {
         throw new Error('DatadogSlo customTags must follow the "key:value" format.');
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"datadog-slo.js","sourceRoot":"","sources":["../../src/datadogv2/datadog-slo.ts"],"names":[],"mappings":";;;;AAgFA,8CAYC;;AA5FD,mCAAmC;AACnC,2CAAuC;AACvC,0DAAqD;AAuExC,QAAA,sBAAsB,GAAG,CAAC,IAAI,EAAE,KAAK,EAAE,KAAK,CAAU,CAAC;AAIpE;;GAEG;AACH,SAAgB,iBAAiB,CAAC,KAAuB;IACvD,kHAAkH;IAClH,MAAM,OAAO,GAAqC;QAChD,IAAI,EAAE,IAAI;QACV,MAAM,EAAE,EAAE;QACV,GAAG,EAAE,EAAE;KACR,CAAC;IAEF,OAAO,8BAAsB,CAAC,GAAG,CAAC,SAAS,CAAC,EAAE,CAAC,CAAC;QAC9C,gBAAgB,EAAE,OAAO,CAAC,KAAK,CAAC;QAChC,SAAS,EAAE,SAAS;KACrB,CAAC,CAAC,CAAC;AACN,CAAC;AAED;;;;GAIG;AACH,MAAa,UAAW,SAAQ,sBAAS;IAGvC,YAAY,KAAgB,EAAE,EAAU,EAAE,KAAsB;QAC9D,KAAK,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC;QAEjB,YAAY,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;QACzB,mBAAmB,CAAC,KAAK,CAAC,UAAU,CAAC,CAAC;QACtC,kBAAkB,CAAC,KAAK,CAAC,UAAU,CAAC,CAAC;QACrC,YAAY,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC;QAC5B,kBAAkB,CAAC,KAAK,CAAC,SAAS,CAAC,CAAC;QAEpC,IAAI,CAAC,sCAAsC,CAAC,KAAK,CAAC,WAAW,EAAE,KAAK,CAAC,UAAU,CAAC,EAAE,CAAC;YACjF,GAAG,CAAC,WAAW,CAAC,EAAE,CAAC,IAAI,CAAC,CAAC,UAAU,CACjC,sFAAsF,CACvF,CAAC;QACJ,CAAC;QAED,MAAM,QAAQ,GAAG,iCAAc,CAAC,oBAAoB,CAAC,IAAI,CAAC,CAAC;QAC3D,MAAM,cAAc,GAAG,iCAAc,CAAC,0BAA0B,CAAC,IAAI,CAAC,CAAC;QACvE,MAAM,WAAW,GAAG,iCAAc,CAAC,uBAAuB,CAAC,IAAI,CAAC,CAAC;QAEjE,iDAAiD;QACjD,MAAM,gBAAgB,GAAG,KAAK,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC,EAAE,gBAAgB,EAAE,SAAS,EAAE,EAAE,EAAE,CAAC,CAAC;YAClF,MAAM,EAAE,gBAAgB;YACxB,SAAS,EAAE,SAAS;SACrB,CAAC,CAAC,CAAC;QAEJ,mGAAmG;QACnG,IAAI,CAAC,GAAG,GAAG,IAAI,GAAG,CAAC,WAAW,CAAC,IAAI,EAAE,KAAK,EAAE;YAC1C,IAAI,EAAE,oBAAoB;YAC1B,UAAU,EAAE;gBACV,IAAI,EAAE,KAAK,CAAC,IAAI;gBAChB,IAAI,EAAE,KAAK,CAAC,OAAO;gBACnB,UAAU,EAAE,KAAK,CAAC,UAAU;gBAC5B,UAAU,EAAE,gBAAgB;gBAC5B,IAAI,EAAE;oBACJ,GAAG,CAAC,KAAK,CAAC,SAAS,IAAI,EAAE,CAAC;oBAC1B,eAAe,KAAK,CAAC,WAAW,EAAE;oBAClC,UAAU,KAAK,CAAC,MAAM,EAAE;oBACxB,cAAc,GAAG,CAAC,KAAK,CAAC,EAAE,CAAC,IAAI,CAAC,CAAC,OAAO,EAAE;oBAC1C,gBAAgB,WAAW,CAAC,WAAW,EAAE;oBACzC,QAAQ,QAAQ,CAAC,WAAW,EAAE;oBAC9B,mBAAmB,cAAc,CAAC,WAAW,EAAE;iBAChD;aACF;SACF,CAAC,CAAC;IACL,CAAC;IAED,IAAI,KAAK;QACP,OAAO,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,IAAI,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC;IACxC,CAAC;;AAnDH,gCAoDC;;;AAED,SAAS,YAAY,CAAC,IAAY;IAChC,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE,EAAE,CAAC;QACjB,MAAM,IAAI,KAAK,CAAC,oCAAoC,CAAC,CAAC;IACxD,CAAC;AACH,CAAC;AAED,SAAS,mBAAmB,CAAC,WAAqB;IAChD,IAAI,WAAW,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QAC7B,MAAM,IAAI,KAAK,CAAC,8DAA8D,CAAC,CAAC;IAClF,CAAC;AACH,CAAC;AAED,SAAS,kBAAkB,CAAC,UAAiC;IAC3D,IAAI,UAAU,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QAC5B,MAAM,IAAI,KAAK,CAAC,4DAA4D,CAAC,CAAC;IAChF,CAAC;AACH,CAAC;AAED,SAAS,YAAY,CAAC,IAAgB;IACpC,IAAI,IAAI,KAAK,SAAS,IAAI,IAAI,KAAK,SAAS,EAAE,CAAC;QAC7C,MAAM,IAAI,KAAK,CAAC,oCAAoC,CAAC,CAAC;IACxD,CAAC;AACH,CAAC;AAED,SAAS,sCAAsC,CAAC,KAAuB,EAAE,UAAiC;IACxG,MAAM,aAAa,GAAG,iBAAiB,CAAC,KAAK,CAAC,CAAC;IAC/C,OAAO,IAAI,CAAC,SAAS,CAAC,aAAa,CAAC,KAAK,IAAI,CAAC,SAAS,CAAC,UAAU,CAAC,CAAC;AACtE,CAAC;AAED,SAAS,kBAAkB,CAAC,UAAqB;IAC/C,IAAI,UAAU,EAAE,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC,GAAG,CAAC,IAAI,EAAE,CAAC,EAAE,CAAC;QACzC,MAAM,IAAI,KAAK,CAAC,sDAAsD,CAAC,CAAC;IAC1E,CAAC;IACD,IAAI,UAAU,EAAE,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC,YAAY,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC;QACrD,MAAM,IAAI,KAAK,CAAC,2DAA2D,CAAC,CAAC;IAC/E,CAAC;AACH,CAAC","sourcesContent":["import * as cdk from 'aws-cdk-lib';\nimport { Construct } from 'constructs';\nimport { RioLandingZone } from '../rio-landing-zone';\n\n/**\n * SLO criticality levels used to select default threshold targets.\n */\nexport type CriticalityLevel = 'high' | 'medium' | 'low';\n\n/**\n * The product streams.\n */\nexport type Stream = 'platform' | 'shipper' | 'transport';\n\n/**\n * Properties of {@link DatadogSlo}\n */\nexport interface DatadogSloProps {\n  /**\n   * The name of the SLO in Datadog.\n   */\n  readonly name: string;\n\n  /**\n   * The Datadog monitor IDs used to calculate the SLO.\n   *\n   * Each entry must be a numeric string (for example \"1234567\").\n   */\n  readonly monitorIds: string[];\n\n  /**\n   * The product stream that this SLO belongs to. This is used for filtering SLOs in dashboards.\n   */\n  readonly stream: Stream;\n\n  /**\n   * The criticality level for the SLO as defined at [Capabilities - RIO Tech Platform Docs - MAN Confluence PRD](https://confluence.collaboration-man.com/x/nLUSEw).\n   */\n  readonly criticality: CriticalityLevel;\n\n  /**\n   * Threshold definitions applied to the SLO.\n   *\n   * Unless you have a specific use case it is recommended to use defaultThresholds(...).\n   */\n  readonly thresholds: DatadogSloThreshold[];\n\n  /**\n   * The SLO type. Only \"monitor\" is supported for now.\n   * Still this property is required to make future extensions more seamless.\n   */\n  readonly sloType: 'monitor';\n\n  /**\n   * Additional tags to apply to the SLO.\n   *\n   * Each entry must follow the \"key:value\" format.\n   */\n  readonly extraTags?: string[];\n}\n\nexport interface DatadogSloThreshold {\n  /**\n   * The target percentage for the SLO (for example 99.5).\n   */\n  readonly targetPercentage: number;\n\n  /**\n   * The timeframe for the target (for example \"7d\", \"30d\", \"90d\").\n   */\n  readonly timeframe: DatadogSloTimeframe;\n}\n\nexport const DATADOG_SLO_TIMEFRAMES = ['7d', '30d', '90d'] as const;\n\nexport type DatadogSloTimeframe = (typeof DATADOG_SLO_TIMEFRAMES)[number];\n\n/**\n * Generate default SLO thresholds for a given criticality level.\n */\nexport function defaultThresholds(level: CriticalityLevel): DatadogSloThreshold[] {\n  // [Capabilities - RIO Tech Platform Docs - MAN Confluence PRD](https://confluence.collaboration-man.com/x/nLUSEw)\n  const targets: Record<CriticalityLevel, number> = {\n    high: 99.5,\n    medium: 98,\n    low: 95,\n  };\n\n  return DATADOG_SLO_TIMEFRAMES.map(timeframe => ({\n    targetPercentage: targets[level],\n    timeframe: timeframe,\n  }));\n}\n\n/**\n * Wrapper around Datadog's CloudFormation `Datadog::SLOs::SLO` with some RIO defaults applied.\n *\n * Currently only SLOs of Type Monitor are implemented.\n */\nexport class DatadogSlo extends Construct {\n  private readonly slo: cdk.CfnResource;\n\n  constructor(scope: Construct, id: string, props: DatadogSloProps) {\n    super(scope, id);\n\n    validateName(props.name);\n    validateMonitorsIds(props.monitorIds);\n    validateThresholds(props.thresholds);\n    validateType(props.sloType);\n    validateCustomTags(props.extraTags);\n\n    if (!matchesDefaultThresholdsForCriticality(props.criticality, props.thresholds)) {\n      cdk.Annotations.of(this).addWarning(\n        'DatadogSlo thresholds do not match the defaults for the specified criticality level.'\n      );\n    }\n\n    const teamName = RioLandingZone.getTeamNameParameter(this);\n    const teamIdentifier = RioLandingZone.getTeamIdentifierParameter(this);\n    const accountName = RioLandingZone.getAccountNameParameter(this);\n\n    // Cloudformation expects uppercase property keys\n    const thresholdsForCfn = props.thresholds.map(({ targetPercentage, timeframe }) => ({\n      Target: targetPercentage,\n      Timeframe: timeframe,\n    }));\n\n    // https://github.com/DataDog/datadog-cloudformation-resources/tree/master/datadog-slos-slo-handler\n    this.slo = new cdk.CfnResource(this, 'SLO', {\n      type: 'Datadog::SLOs::SLO',\n      properties: {\n        Name: props.name,\n        Type: props.sloType,\n        MonitorIds: props.monitorIds,\n        Thresholds: thresholdsForCfn,\n        Tags: [\n          ...(props.extraTags ?? []),\n          `criticality:${props.criticality}`,\n          `stream:${props.stream}`,\n          `account_id:${cdk.Stack.of(this).account}`,\n          `account_name:${accountName.stringValue}`,\n          `team:${teamName.stringValue}`,\n          `team_identifier:${teamIdentifier.stringValue}`,\n        ],\n      },\n    });\n  }\n\n  get sloId() {\n    return cdk.Fn.ref(this.slo.logicalId);\n  }\n}\n\nfunction validateName(name: string) {\n  if (!name.trim()) {\n    throw new Error('DatadogSlo name must be non-empty.');\n  }\n}\n\nfunction validateMonitorsIds(monitorsIds: string[]) {\n  if (monitorsIds.length === 0) {\n    throw new Error('DatadogSlo monitorsIds must include at least one monitor ID.');\n  }\n}\n\nfunction validateThresholds(thresholds: DatadogSloThreshold[]) {\n  if (thresholds.length === 0) {\n    throw new Error('DatadogSlo thresholds must include at least one threshold.');\n  }\n}\n\nfunction validateType(type?: 'monitor') {\n  if (type !== undefined && type !== 'monitor') {\n    throw new Error('DatadogSlo type must be \"monitor\".');\n  }\n}\n\nfunction matchesDefaultThresholdsForCriticality(level: CriticalityLevel, thresholds: DatadogSloThreshold[]) {\n  const defaultValues = defaultThresholds(level);\n  return JSON.stringify(defaultValues) === JSON.stringify(thresholds);\n}\n\nfunction validateCustomTags(customTags?: string[]) {\n  if (customTags?.some(tag => !tag.trim())) {\n    throw new Error('DatadogSlo customTags must not contain empty values.');\n  }\n  if (customTags?.some(tag => !/^[^:]+:.+$/.test(tag))) {\n    throw new Error('DatadogSlo customTags must follow the \"key:value\" format.');\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"datadog-slo.js","sourceRoot":"","sources":["../../src/datadogv2/datadog-slo.ts"],"names":[],"mappings":";;;;AAuFA,8CAYC;;AAnGD,mCAAmC;AACnC,2CAAuC;AACvC,0DAAqD;AAuExC,QAAA,sBAAsB,GAAG,CAAC,IAAI,EAAE,KAAK,EAAE,KAAK,CAAU,CAAC;AAIpE;;;;;;;;;GASG;AACH,SAAgB,iBAAiB,CAAC,KAAuB;IACvD,kHAAkH;IAClH,MAAM,OAAO,GAAqC;QAChD,IAAI,EAAE,IAAI;QACV,MAAM,EAAE,EAAE;QACV,GAAG,EAAE,EAAE;KACR,CAAC;IAEF,OAAO,8BAAsB,CAAC,GAAG,CAAC,SAAS,CAAC,EAAE,CAAC,CAAC;QAC9C,gBAAgB,EAAE,OAAO,CAAC,KAAK,CAAC;QAChC,SAAS,EAAE,SAAS;KACrB,CAAC,CAAC,CAAC;AACN,CAAC;AAED;;;;GAIG;AACH,MAAa,UAAW,SAAQ,sBAAS;IAGvC,YAAY,KAAgB,EAAE,EAAU,EAAE,KAAsB;QAC9D,KAAK,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC;QAEjB,YAAY,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;QACzB,mBAAmB,CAAC,KAAK,CAAC,UAAU,CAAC,CAAC;QACtC,kBAAkB,CAAC,KAAK,CAAC,UAAU,CAAC,CAAC;QACrC,YAAY,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC;QAC5B,kBAAkB,CAAC,KAAK,CAAC,SAAS,CAAC,CAAC;QAEpC,IAAI,CAAC,sCAAsC,CAAC,KAAK,CAAC,WAAW,EAAE,KAAK,CAAC,UAAU,CAAC,EAAE,CAAC;YACjF,GAAG,CAAC,WAAW,CAAC,EAAE,CAAC,IAAI,CAAC,CAAC,UAAU,CACjC,sFAAsF,CACvF,CAAC;QACJ,CAAC;QAED,MAAM,QAAQ,GAAG,iCAAc,CAAC,oBAAoB,CAAC,IAAI,CAAC,CAAC;QAC3D,MAAM,cAAc,GAAG,iCAAc,CAAC,0BAA0B,CAAC,IAAI,CAAC,CAAC;QACvE,MAAM,WAAW,GAAG,iCAAc,CAAC,uBAAuB,CAAC,IAAI,CAAC,CAAC;QAEjE,iDAAiD;QACjD,MAAM,gBAAgB,GAAG,KAAK,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC,EAAE,gBAAgB,EAAE,SAAS,EAAE,EAAE,EAAE,CAAC,CAAC;YAClF,MAAM,EAAE,gBAAgB;YACxB,SAAS,EAAE,SAAS;SACrB,CAAC,CAAC,CAAC;QAEJ,mGAAmG;QACnG,IAAI,CAAC,GAAG,GAAG,IAAI,GAAG,CAAC,WAAW,CAAC,IAAI,EAAE,KAAK,EAAE;YAC1C,IAAI,EAAE,oBAAoB;YAC1B,UAAU,EAAE;gBACV,IAAI,EAAE,KAAK,CAAC,IAAI;gBAChB,IAAI,EAAE,KAAK,CAAC,OAAO;gBACnB,UAAU,EAAE,KAAK,CAAC,UAAU;gBAC5B,UAAU,EAAE,gBAAgB;gBAC5B,IAAI,EAAE;oBACJ,GAAG,CAAC,KAAK,CAAC,SAAS,IAAI,EAAE,CAAC;oBAC1B,eAAe,KAAK,CAAC,WAAW,EAAE;oBAClC,UAAU,KAAK,CAAC,MAAM,EAAE;oBACxB,cAAc,GAAG,CAAC,KAAK,CAAC,EAAE,CAAC,IAAI,CAAC,CAAC,OAAO,EAAE;oBAC1C,gBAAgB,WAAW,CAAC,WAAW,EAAE;oBACzC,QAAQ,QAAQ,CAAC,WAAW,EAAE;oBAC9B,mBAAmB,cAAc,CAAC,WAAW,EAAE;iBAChD;aACF;SACF,CAAC,CAAC;IACL,CAAC;IAED,IAAI,KAAK;QACP,OAAO,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,IAAI,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC;IACxC,CAAC;;AAnDH,gCAoDC;;;AAED,SAAS,YAAY,CAAC,IAAY;IAChC,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE,EAAE,CAAC;QACjB,MAAM,IAAI,KAAK,CAAC,oCAAoC,CAAC,CAAC;IACxD,CAAC;AACH,CAAC;AAED,SAAS,mBAAmB,CAAC,WAAqB;IAChD,IAAI,WAAW,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QAC7B,MAAM,IAAI,KAAK,CAAC,8DAA8D,CAAC,CAAC;IAClF,CAAC;AACH,CAAC;AAED,SAAS,kBAAkB,CAAC,UAAiC;IAC3D,IAAI,UAAU,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QAC5B,MAAM,IAAI,KAAK,CAAC,4DAA4D,CAAC,CAAC;IAChF,CAAC;AACH,CAAC;AAED,SAAS,YAAY,CAAC,IAAgB;IACpC,IAAI,IAAI,KAAK,SAAS,IAAI,IAAI,KAAK,SAAS,EAAE,CAAC;QAC7C,MAAM,IAAI,KAAK,CAAC,oCAAoC,CAAC,CAAC;IACxD,CAAC;AACH,CAAC;AAED,SAAS,sCAAsC,CAAC,KAAuB,EAAE,UAAiC;IACxG,MAAM,aAAa,GAAG,iBAAiB,CAAC,KAAK,CAAC,CAAC;IAC/C,OAAO,IAAI,CAAC,SAAS,CAAC,aAAa,CAAC,KAAK,IAAI,CAAC,SAAS,CAAC,UAAU,CAAC,CAAC;AACtE,CAAC;AAED,SAAS,kBAAkB,CAAC,UAAqB;IAC/C,IAAI,UAAU,EAAE,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC,GAAG,CAAC,IAAI,EAAE,CAAC,EAAE,CAAC;QACzC,MAAM,IAAI,KAAK,CAAC,sDAAsD,CAAC,CAAC;IAC1E,CAAC;IACD,IAAI,UAAU,EAAE,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC,YAAY,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC;QACrD,MAAM,IAAI,KAAK,CAAC,2DAA2D,CAAC,CAAC;IAC/E,CAAC;AACH,CAAC","sourcesContent":["import * as cdk from 'aws-cdk-lib';\nimport { Construct } from 'constructs';\nimport { RioLandingZone } from '../rio-landing-zone';\n\n/**\n * SLO criticality levels used to select default threshold targets.\n */\nexport type CriticalityLevel = 'high' | 'medium' | 'low';\n\n/**\n * The product streams.\n */\nexport type Stream = 'platform' | 'shipper' | 'transport';\n\n/**\n * Properties of {@link DatadogSlo}\n */\nexport interface DatadogSloProps {\n  /**\n   * The name of the SLO in Datadog.\n   */\n  readonly name: string;\n\n  /**\n   * The Datadog monitor IDs used to calculate the SLO.\n   *\n   * Each entry must be a numeric string (for example \"1234567\").\n   */\n  readonly monitorIds: string[];\n\n  /**\n   * The product stream that this SLO belongs to. This is used for filtering SLOs in dashboards.\n   */\n  readonly stream: Stream;\n\n  /**\n   * The criticality level for the SLO as defined at [Capabilities - RIO Tech Platform Docs - MAN Confluence PRD](https://confluence.collaboration-man.com/x/nLUSEw).\n   */\n  readonly criticality: CriticalityLevel;\n\n  /**\n   * Threshold definitions applied to the SLO.\n   *\n   * Unless you have a specific use case it is recommended to use defaultThresholds(...).\n   */\n  readonly thresholds: DatadogSloThreshold[];\n\n  /**\n   * The SLO type. Only \"monitor\" is supported for now.\n   * Still this property is required to make future extensions more seamless.\n   */\n  readonly sloType: 'monitor';\n\n  /**\n   * Additional tags to apply to the SLO.\n   *\n   * Each entry must follow the \"key:value\" format.\n   */\n  readonly extraTags?: string[];\n}\n\nexport interface DatadogSloThreshold {\n  /**\n   * The target percentage for the SLO (for example 99.5).\n   */\n  readonly targetPercentage: number;\n\n  /**\n   * The timeframe for the target (for example \"7d\", \"30d\", \"90d\").\n   */\n  readonly timeframe: DatadogSloTimeframe;\n}\n\nexport const DATADOG_SLO_TIMEFRAMES = ['7d', '30d', '90d'] as const;\n\nexport type DatadogSloTimeframe = (typeof DATADOG_SLO_TIMEFRAMES)[number];\n\n/**\n * Generate default SLO thresholds for a given criticality level.\n *\n * Prefer this helper unless a specific target has been agreed for the service.\n *\n * Example:\n * ```ts\n * thresholds: defaultThresholds('medium')\n * ```\n */\nexport function defaultThresholds(level: CriticalityLevel): DatadogSloThreshold[] {\n  // [Capabilities - RIO Tech Platform Docs - MAN Confluence PRD](https://confluence.collaboration-man.com/x/nLUSEw)\n  const targets: Record<CriticalityLevel, number> = {\n    high: 99.5,\n    medium: 98,\n    low: 95,\n  };\n\n  return DATADOG_SLO_TIMEFRAMES.map(timeframe => ({\n    targetPercentage: targets[level],\n    timeframe: timeframe,\n  }));\n}\n\n/**\n * Wrapper around Datadog's CloudFormation `Datadog::SLOs::SLO` with some RIO defaults applied.\n *\n * Currently only SLOs of Type Monitor are implemented.\n */\nexport class DatadogSlo extends Construct {\n  private readonly slo: cdk.CfnResource;\n\n  constructor(scope: Construct, id: string, props: DatadogSloProps) {\n    super(scope, id);\n\n    validateName(props.name);\n    validateMonitorsIds(props.monitorIds);\n    validateThresholds(props.thresholds);\n    validateType(props.sloType);\n    validateCustomTags(props.extraTags);\n\n    if (!matchesDefaultThresholdsForCriticality(props.criticality, props.thresholds)) {\n      cdk.Annotations.of(this).addWarning(\n        'DatadogSlo thresholds do not match the defaults for the specified criticality level.'\n      );\n    }\n\n    const teamName = RioLandingZone.getTeamNameParameter(this);\n    const teamIdentifier = RioLandingZone.getTeamIdentifierParameter(this);\n    const accountName = RioLandingZone.getAccountNameParameter(this);\n\n    // Cloudformation expects uppercase property keys\n    const thresholdsForCfn = props.thresholds.map(({ targetPercentage, timeframe }) => ({\n      Target: targetPercentage,\n      Timeframe: timeframe,\n    }));\n\n    // https://github.com/DataDog/datadog-cloudformation-resources/tree/master/datadog-slos-slo-handler\n    this.slo = new cdk.CfnResource(this, 'SLO', {\n      type: 'Datadog::SLOs::SLO',\n      properties: {\n        Name: props.name,\n        Type: props.sloType,\n        MonitorIds: props.monitorIds,\n        Thresholds: thresholdsForCfn,\n        Tags: [\n          ...(props.extraTags ?? []),\n          `criticality:${props.criticality}`,\n          `stream:${props.stream}`,\n          `account_id:${cdk.Stack.of(this).account}`,\n          `account_name:${accountName.stringValue}`,\n          `team:${teamName.stringValue}`,\n          `team_identifier:${teamIdentifier.stringValue}`,\n        ],\n      },\n    });\n  }\n\n  get sloId() {\n    return cdk.Fn.ref(this.slo.logicalId);\n  }\n}\n\nfunction validateName(name: string) {\n  if (!name.trim()) {\n    throw new Error('DatadogSlo name must be non-empty.');\n  }\n}\n\nfunction validateMonitorsIds(monitorsIds: string[]) {\n  if (monitorsIds.length === 0) {\n    throw new Error('DatadogSlo monitorsIds must include at least one monitor ID.');\n  }\n}\n\nfunction validateThresholds(thresholds: DatadogSloThreshold[]) {\n  if (thresholds.length === 0) {\n    throw new Error('DatadogSlo thresholds must include at least one threshold.');\n  }\n}\n\nfunction validateType(type?: 'monitor') {\n  if (type !== undefined && type !== 'monitor') {\n    throw new Error('DatadogSlo type must be \"monitor\".');\n  }\n}\n\nfunction matchesDefaultThresholdsForCriticality(level: CriticalityLevel, thresholds: DatadogSloThreshold[]) {\n  const defaultValues = defaultThresholds(level);\n  return JSON.stringify(defaultValues) === JSON.stringify(thresholds);\n}\n\nfunction validateCustomTags(customTags?: string[]) {\n  if (customTags?.some(tag => !tag.trim())) {\n    throw new Error('DatadogSlo customTags must not contain empty values.');\n  }\n  if (customTags?.some(tag => !/^[^:]+:.+$/.test(tag))) {\n    throw new Error('DatadogSlo customTags must follow the \"key:value\" format.');\n  }\n}\n"]}