@cdklabs/cdk-appmod-catalog-blueprints 1.0.0

package/lib/utilities/lambda-iam-utils.d.ts

@@ -0,0 +1,145 @@
+import * as iam from 'aws-cdk-lib/aws-iam';
+import { Construct } from 'constructs';
+/**
+ * Stack information
+ */
+export interface LambdaIamUtilsStackInfo {
+    readonly region: string;
+    readonly account: string;
+}
+/**
+ * Configuration options for Lambda CloudWatch Logs permissions
+ */
+export interface LambdaLogsPermissionsProps {
+    /**
+     * The construct scope (used to generate unique names)
+     */
+    readonly scope: Construct;
+    /**
+     * The base name of the Lambda function
+     */
+    readonly functionName: string;
+    /**
+     * Custom log group name pattern
+     * @default '/aws/lambda/{uniqueFunctionName}'
+     */
+    readonly logGroupName?: string;
+    /**
+     * AWS region for the log group ARN
+     */
+    readonly region: string;
+    /**
+     * AWS account ID for the log group ARN
+     */
+    readonly account: string;
+}
+/**
+ * Result of creating Lambda logs permissions
+ */
+export interface LambdaLogsPermissionsResult {
+    /**
+     * The policy statements for CloudWatch Logs
+     */
+    readonly policyStatements: iam.PolicyStatement[];
+    /**
+     * The unique function name that was generated
+     */
+    readonly uniqueFunctionName: string;
+}
+/**
+ * Utility class for creating secure Lambda IAM policy statements with minimal permissions
+ */
+export declare class LambdaIamUtils {
+    /**
+     * Creates CloudWatch Logs policy statements for Lambda execution
+     *
+     * @param props Configuration properties
+     * @returns Object containing policy statements and the unique function name
+     */
+    static createLogsPermissions(props: LambdaLogsPermissionsProps): LambdaLogsPermissionsResult;
+    static generateLambdaVPCPermissions(): iam.PolicyStatement;
+    /**
+     * Generates a unique function name using CDK's built-in functionality
+     *
+     * @param scope The construct scope
+     * @param baseName The base name for the function
+     * @returns Unique function name
+     */
+    static generateUniqueFunctionName(scope: Construct, baseName: string): string;
+    /**
+     * Creates VPC permissions for Lambda functions running in VPC
+     *
+     * @returns Array of IAM PolicyStatements for VPC access
+     */
+    static createVpcPermissions(): iam.PolicyStatement[];
+    /**
+     * Creates X-Ray tracing permissions for Lambda functions
+     *
+     * @returns Array of IAM PolicyStatements for X-Ray tracing
+     */
+    static createXRayPermissions(): iam.PolicyStatement[];
+    /**
+     * Helper method to get region and account from a construct
+     *
+     * @param scope The construct scope
+     * @returns LambdaIamUtilsStackInfo
+     */
+    static getStackInfo(scope: Construct): LambdaIamUtilsStackInfo;
+    /**
+     * Creates a policy statement for DynamoDB table access
+     *
+     * @param tableArn The ARN of the DynamoDB table
+     * @param actions The DynamoDB actions to allow
+     * @returns PolicyStatement for DynamoDB access
+     */
+    static createDynamoDbPolicyStatement(tableArn: string, actions?: string[]): iam.PolicyStatement;
+    /**
+     * Creates a policy statement for S3 bucket access
+     *
+     * @param bucketArn The ARN of the S3 bucket
+     * @param actions The S3 actions to allow
+     * @param includeObjects Whether to include object-level permissions
+     * @returns PolicyStatement for S3 access
+     */
+    static createS3PolicyStatement(bucketArn: string, actions?: string[], includeObjects?: boolean): iam.PolicyStatement;
+    /**
+     * Creates a policy statement for SQS queue access
+     *
+     * @param queueArn The ARN of the SQS queue
+     * @param actions The SQS actions to allow
+     * @returns PolicyStatement for SQS access
+     */
+    static createSqsPolicyStatement(queueArn: string, actions?: string[]): iam.PolicyStatement;
+    /**
+     * Creates a policy statement for SNS topic access
+     *
+     * @param topicArn The ARN of the SNS topic
+     * @param actions The SNS actions to allow
+     * @returns PolicyStatement for SNS access
+     */
+    static createSnsPolicyStatement(topicArn: string, actions?: string[]): iam.PolicyStatement;
+    /**
+     * Creates a policy statement for Step Functions execution
+     *
+     * @param stateMachineArn The ARN of the Step Functions state machine
+     * @param actions The Step Functions actions to allow
+     * @returns PolicyStatement for Step Functions access
+     */
+    static createStepFunctionsPolicyStatement(stateMachineArn: string, actions?: string[]): iam.PolicyStatement;
+    /**
+     * Creates a policy statement for Secrets Manager access
+     *
+     * @param secretArn The ARN of the secret
+     * @param actions The Secrets Manager actions to allow
+     * @returns PolicyStatement for Secrets Manager access
+     */
+    static createSecretsManagerPolicyStatement(secretArn: string, actions?: string[]): iam.PolicyStatement;
+    /**
+     * Creates a policy statement for KMS key access
+     *
+     * @param keyArn The ARN of the KMS key
+     * @param actions The KMS actions to allow
+     * @returns PolicyStatement for KMS access
+     */
+    static createKmsPolicyStatement(keyArn: string, actions?: string[]): iam.PolicyStatement;
+}

package/lib/utilities/lambda-iam-utils.js

@@ -0,0 +1,235 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LambdaIamUtils = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+const cdk = require("aws-cdk-lib");
+const aws_cdk_lib_1 = require("aws-cdk-lib");
+const iam = require("aws-cdk-lib/aws-iam");
+/**
+ * Utility class for creating secure Lambda IAM policy statements with minimal permissions
+ */
+class LambdaIamUtils {
+    /**
+     * Creates CloudWatch Logs policy statements for Lambda execution
+     *
+     * @param props Configuration properties
+     * @returns Object containing policy statements and the unique function name
+     */
+    static createLogsPermissions(props) {
+        // Generate unique function name using construct node path
+        const uniqueFunctionName = LambdaIamUtils.generateUniqueFunctionName(props.scope, props.functionName);
+        const logGroupName = props.logGroupName || `/aws/lambda/${uniqueFunctionName}`;
+        const policyStatements = [
+            // Permission to create log group
+            new iam.PolicyStatement({
+                effect: iam.Effect.ALLOW,
+                actions: ['logs:CreateLogGroup'],
+                resources: [
+                    `arn:aws:logs:${props.region}:${props.account}:log-group:${logGroupName}:*`,
+                ],
+            }),
+            // Permission to create log streams and put log events
+            new iam.PolicyStatement({
+                effect: iam.Effect.ALLOW,
+                actions: [
+                    'logs:CreateLogStream',
+                    'logs:PutLogEvents',
+                ],
+                resources: [
+                    `arn:aws:logs:${props.region}:${props.account}:log-group:${logGroupName}:*`,
+                ],
+            }),
+        ];
+        return {
+            policyStatements,
+            uniqueFunctionName,
+        };
+    }
+    static generateLambdaVPCPermissions() {
+        return new iam.PolicyStatement({
+            effect: iam.Effect.ALLOW,
+            actions: [
+                'ec2:CreateNetworkInterface',
+                'ec2:DescribeNetworkInterfaces',
+                'ec2:DescribeSubnets',
+                'ec2:DeleteNetworkInterface',
+                'ec2:AssignPrivateIpAddresses',
+                'ec2:UnassignPrivateIpAddresses',
+                'ec2:DescribeSecurityGroups',
+                'ec2:DescribeVpcs',
+                'ec2:GetSecurityGroupsForVpc',
+            ],
+            resources: ['*'],
+        });
+    }
+    /**
+     * Generates a unique function name using CDK's built-in functionality
+     *
+     * @param scope The construct scope
+     * @param baseName The base name for the function
+     * @returns Unique function name
+     */
+    static generateUniqueFunctionName(scope, baseName) {
+        return `${baseName}-${aws_cdk_lib_1.Names.uniqueResourceName(scope, { maxLength: 64 - (baseName.length + 1) }).toLowerCase()}`;
+    }
+    /**
+     * Creates VPC permissions for Lambda functions running in VPC
+     *
+     * @returns Array of IAM PolicyStatements for VPC access
+     */
+    static createVpcPermissions() {
+        return [
+            new iam.PolicyStatement({
+                effect: iam.Effect.ALLOW,
+                actions: [
+                    'ec2:CreateNetworkInterface',
+                    'ec2:DescribeNetworkInterfaces',
+                    'ec2:DeleteNetworkInterface',
+                    'ec2:AttachNetworkInterface',
+                    'ec2:DetachNetworkInterface',
+                ],
+                resources: ['*'], // VPC permissions require wildcard resources
+            }),
+        ];
+    }
+    /**
+     * Creates X-Ray tracing permissions for Lambda functions
+     *
+     * @returns Array of IAM PolicyStatements for X-Ray tracing
+     */
+    static createXRayPermissions() {
+        return [
+            new iam.PolicyStatement({
+                effect: iam.Effect.ALLOW,
+                actions: [
+                    'xray:PutTraceSegments',
+                    'xray:PutTelemetryRecords',
+                ],
+                resources: ['*'], // X-Ray permissions require wildcard resources
+            }),
+        ];
+    }
+    /**
+     * Helper method to get region and account from a construct
+     *
+     * @param scope The construct scope
+     * @returns LambdaIamUtilsStackInfo
+     */
+    static getStackInfo(scope) {
+        const stack = cdk.Stack.of(scope);
+        return {
+            region: stack.region,
+            account: stack.account,
+        };
+    }
+    /**
+     * Creates a policy statement for DynamoDB table access
+     *
+     * @param tableArn The ARN of the DynamoDB table
+     * @param actions The DynamoDB actions to allow
+     * @returns PolicyStatement for DynamoDB access
+     */
+    static createDynamoDbPolicyStatement(tableArn, actions = ['dynamodb:GetItem', 'dynamodb:PutItem', 'dynamodb:UpdateItem', 'dynamodb:DeleteItem', 'dynamodb:Query', 'dynamodb:Scan']) {
+        return new iam.PolicyStatement({
+            effect: iam.Effect.ALLOW,
+            actions,
+            resources: [tableArn, `${tableArn}/index/*`], // Include GSI access
+        });
+    }
+    /**
+     * Creates a policy statement for S3 bucket access
+     *
+     * @param bucketArn The ARN of the S3 bucket
+     * @param actions The S3 actions to allow
+     * @param includeObjects Whether to include object-level permissions
+     * @returns PolicyStatement for S3 access
+     */
+    static createS3PolicyStatement(bucketArn, actions = ['s3:GetObject', 's3:PutObject'], includeObjects = true) {
+        const resources = [bucketArn];
+        if (includeObjects) {
+            resources.push(`${bucketArn}/*`);
+        }
+        return new iam.PolicyStatement({
+            effect: iam.Effect.ALLOW,
+            actions,
+            resources,
+        });
+    }
+    /**
+     * Creates a policy statement for SQS queue access
+     *
+     * @param queueArn The ARN of the SQS queue
+     * @param actions The SQS actions to allow
+     * @returns PolicyStatement for SQS access
+     */
+    static createSqsPolicyStatement(queueArn, actions = ['sqs:ReceiveMessage', 'sqs:DeleteMessage', 'sqs:GetQueueAttributes']) {
+        return new iam.PolicyStatement({
+            effect: iam.Effect.ALLOW,
+            actions,
+            resources: [queueArn],
+        });
+    }
+    /**
+     * Creates a policy statement for SNS topic access
+     *
+     * @param topicArn The ARN of the SNS topic
+     * @param actions The SNS actions to allow
+     * @returns PolicyStatement for SNS access
+     */
+    static createSnsPolicyStatement(topicArn, actions = ['sns:Publish']) {
+        return new iam.PolicyStatement({
+            effect: iam.Effect.ALLOW,
+            actions,
+            resources: [topicArn],
+        });
+    }
+    /**
+     * Creates a policy statement for Step Functions execution
+     *
+     * @param stateMachineArn The ARN of the Step Functions state machine
+     * @param actions The Step Functions actions to allow
+     * @returns PolicyStatement for Step Functions access
+     */
+    static createStepFunctionsPolicyStatement(stateMachineArn, actions = ['states:StartExecution']) {
+        return new iam.PolicyStatement({
+            effect: iam.Effect.ALLOW,
+            actions,
+            resources: [stateMachineArn],
+        });
+    }
+    /**
+     * Creates a policy statement for Secrets Manager access
+     *
+     * @param secretArn The ARN of the secret
+     * @param actions The Secrets Manager actions to allow
+     * @returns PolicyStatement for Secrets Manager access
+     */
+    static createSecretsManagerPolicyStatement(secretArn, actions = ['secretsmanager:GetSecretValue']) {
+        return new iam.PolicyStatement({
+            effect: iam.Effect.ALLOW,
+            actions,
+            resources: [secretArn],
+        });
+    }
+    /**
+     * Creates a policy statement for KMS key access
+     *
+     * @param keyArn The ARN of the KMS key
+     * @param actions The KMS actions to allow
+     * @returns PolicyStatement for KMS access
+     */
+    static createKmsPolicyStatement(keyArn, actions = ['kms:Decrypt', 'kms:GenerateDataKey']) {
+        return new iam.PolicyStatement({
+            effect: iam.Effect.ALLOW,
+            actions,
+            resources: [keyArn],
+        });
+    }
+}
+exports.LambdaIamUtils = LambdaIamUtils;
+_a = JSII_RTTI_SYMBOL_1;
+LambdaIamUtils[_a] = { fqn: "@cdklabs/cdk-appmod-catalog-blueprints.LambdaIamUtils", version: "1.0.0" };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"lambda-iam-utils.js","sourceRoot":"","sources":["../../use-cases/utilities/lambda-iam-utils.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.\n// SPDX-License-Identifier: Apache-2.0\nimport * as cdk from 'aws-cdk-lib';\nimport { Names } from 'aws-cdk-lib';\nimport * as iam from 'aws-cdk-lib/aws-iam';\nimport { Construct } from 'constructs';\n\n/**\n * Stack information\n */\nexport interface LambdaIamUtilsStackInfo {\n  readonly region: string;\n  readonly account: string;\n}\n\n/**\n * Configuration options for Lambda CloudWatch Logs permissions\n */\nexport interface LambdaLogsPermissionsProps {\n  /**\n   * The construct scope (used to generate unique names)\n   */\n  readonly scope: Construct;\n\n  /**\n   * The base name of the Lambda function\n   */\n  readonly functionName: string;\n\n  /**\n   * Custom log group name pattern\n   * @default '/aws/lambda/{uniqueFunctionName}'\n   */\n  readonly logGroupName?: string;\n\n  /**\n   * AWS region for the log group ARN\n   */\n  readonly region: string;\n\n  /**\n   * AWS account ID for the log group ARN\n   */\n  readonly account: string;\n}\n\n/**\n * Result of creating Lambda logs permissions\n */\nexport interface LambdaLogsPermissionsResult {\n  /**\n   * The policy statements for CloudWatch Logs\n   */\n  readonly policyStatements: iam.PolicyStatement[];\n\n  /**\n   * The unique function name that was generated\n   */\n  readonly uniqueFunctionName: string;\n}\n\n/**\n * Utility class for creating secure Lambda IAM policy statements with minimal permissions\n */\nexport class LambdaIamUtils {\n  /**\n   * Creates CloudWatch Logs policy statements for Lambda execution\n   *\n   * @param props Configuration properties\n   * @returns Object containing policy statements and the unique function name\n   */\n  public static createLogsPermissions(props: LambdaLogsPermissionsProps): LambdaLogsPermissionsResult {\n    // Generate unique function name using construct node path\n    const uniqueFunctionName = LambdaIamUtils.generateUniqueFunctionName(props.scope, props.functionName);\n    const logGroupName = props.logGroupName || `/aws/lambda/${uniqueFunctionName}`;\n\n    const policyStatements = [\n      // Permission to create log group\n      new iam.PolicyStatement({\n        effect: iam.Effect.ALLOW,\n        actions: ['logs:CreateLogGroup'],\n        resources: [\n          `arn:aws:logs:${props.region}:${props.account}:log-group:${logGroupName}:*`,\n        ],\n      }),\n      // Permission to create log streams and put log events\n      new iam.PolicyStatement({\n        effect: iam.Effect.ALLOW,\n        actions: [\n          'logs:CreateLogStream',\n          'logs:PutLogEvents',\n        ],\n        resources: [\n          `arn:aws:logs:${props.region}:${props.account}:log-group:${logGroupName}:*`,\n        ],\n      }),\n    ];\n\n    return {\n      policyStatements,\n      uniqueFunctionName,\n    };\n  }\n\n  public static generateLambdaVPCPermissions(): iam.PolicyStatement {\n    return new iam.PolicyStatement({\n      effect: iam.Effect.ALLOW,\n      actions: [\n        'ec2:CreateNetworkInterface',\n        'ec2:DescribeNetworkInterfaces',\n        'ec2:DescribeSubnets',\n        'ec2:DeleteNetworkInterface',\n        'ec2:AssignPrivateIpAddresses',\n        'ec2:UnassignPrivateIpAddresses',\n        'ec2:DescribeSecurityGroups',\n        'ec2:DescribeVpcs',\n        'ec2:GetSecurityGroupsForVpc',\n      ],\n      resources: ['*'],\n    });\n  }\n\n  /**\n   * Generates a unique function name using CDK's built-in functionality\n   *\n   * @param scope The construct scope\n   * @param baseName The base name for the function\n   * @returns Unique function name\n   */\n  public static generateUniqueFunctionName(scope: Construct, baseName: string): string {\n    return `${baseName}-${Names.uniqueResourceName(scope, { maxLength: 64 - (baseName.length + 1) }).toLowerCase()}`;\n  }\n\n  /**\n   * Creates VPC permissions for Lambda functions running in VPC\n   *\n   * @returns Array of IAM PolicyStatements for VPC access\n   */\n  public static createVpcPermissions(): iam.PolicyStatement[] {\n    return [\n      new iam.PolicyStatement({\n        effect: iam.Effect.ALLOW,\n        actions: [\n          'ec2:CreateNetworkInterface',\n          'ec2:DescribeNetworkInterfaces',\n          'ec2:DeleteNetworkInterface',\n          'ec2:AttachNetworkInterface',\n          'ec2:DetachNetworkInterface',\n        ],\n        resources: ['*'], // VPC permissions require wildcard resources\n      }),\n    ];\n  }\n\n  /**\n   * Creates X-Ray tracing permissions for Lambda functions\n   *\n   * @returns Array of IAM PolicyStatements for X-Ray tracing\n   */\n  public static createXRayPermissions(): iam.PolicyStatement[] {\n    return [\n      new iam.PolicyStatement({\n        effect: iam.Effect.ALLOW,\n        actions: [\n          'xray:PutTraceSegments',\n          'xray:PutTelemetryRecords',\n        ],\n        resources: ['*'], // X-Ray permissions require wildcard resources\n      }),\n    ];\n  }\n\n  /**\n   * Helper method to get region and account from a construct\n   *\n   * @param scope The construct scope\n   * @returns LambdaIamUtilsStackInfo\n   */\n  public static getStackInfo(scope: Construct): LambdaIamUtilsStackInfo {\n    const stack = cdk.Stack.of(scope);\n    return {\n      region: stack.region,\n      account: stack.account,\n    };\n  }\n\n  /**\n   * Creates a policy statement for DynamoDB table access\n   *\n   * @param tableArn The ARN of the DynamoDB table\n   * @param actions The DynamoDB actions to allow\n   * @returns PolicyStatement for DynamoDB access\n   */\n  public static createDynamoDbPolicyStatement(\n    tableArn: string,\n    actions: string[] = ['dynamodb:GetItem', 'dynamodb:PutItem', 'dynamodb:UpdateItem', 'dynamodb:DeleteItem', 'dynamodb:Query', 'dynamodb:Scan'],\n  ): iam.PolicyStatement {\n    return new iam.PolicyStatement({\n      effect: iam.Effect.ALLOW,\n      actions,\n      resources: [tableArn, `${tableArn}/index/*`], // Include GSI access\n    });\n  }\n\n  /**\n   * Creates a policy statement for S3 bucket access\n   *\n   * @param bucketArn The ARN of the S3 bucket\n   * @param actions The S3 actions to allow\n   * @param includeObjects Whether to include object-level permissions\n   * @returns PolicyStatement for S3 access\n   */\n  public static createS3PolicyStatement(\n    bucketArn: string,\n    actions: string[] = ['s3:GetObject', 's3:PutObject'],\n    includeObjects: boolean = true,\n  ): iam.PolicyStatement {\n    const resources = [bucketArn];\n    if (includeObjects) {\n      resources.push(`${bucketArn}/*`);\n    }\n\n    return new iam.PolicyStatement({\n      effect: iam.Effect.ALLOW,\n      actions,\n      resources,\n    });\n  }\n\n  /**\n   * Creates a policy statement for SQS queue access\n   *\n   * @param queueArn The ARN of the SQS queue\n   * @param actions The SQS actions to allow\n   * @returns PolicyStatement for SQS access\n   */\n  public static createSqsPolicyStatement(\n    queueArn: string,\n    actions: string[] = ['sqs:ReceiveMessage', 'sqs:DeleteMessage', 'sqs:GetQueueAttributes'],\n  ): iam.PolicyStatement {\n    return new iam.PolicyStatement({\n      effect: iam.Effect.ALLOW,\n      actions,\n      resources: [queueArn],\n    });\n  }\n\n  /**\n   * Creates a policy statement for SNS topic access\n   *\n   * @param topicArn The ARN of the SNS topic\n   * @param actions The SNS actions to allow\n   * @returns PolicyStatement for SNS access\n   */\n  public static createSnsPolicyStatement(\n    topicArn: string,\n    actions: string[] = ['sns:Publish'],\n  ): iam.PolicyStatement {\n    return new iam.PolicyStatement({\n      effect: iam.Effect.ALLOW,\n      actions,\n      resources: [topicArn],\n    });\n  }\n\n  /**\n   * Creates a policy statement for Step Functions execution\n   *\n   * @param stateMachineArn The ARN of the Step Functions state machine\n   * @param actions The Step Functions actions to allow\n   * @returns PolicyStatement for Step Functions access\n   */\n  public static createStepFunctionsPolicyStatement(\n    stateMachineArn: string,\n    actions: string[] = ['states:StartExecution'],\n  ): iam.PolicyStatement {\n    return new iam.PolicyStatement({\n      effect: iam.Effect.ALLOW,\n      actions,\n      resources: [stateMachineArn],\n    });\n  }\n\n  /**\n   * Creates a policy statement for Secrets Manager access\n   *\n   * @param secretArn The ARN of the secret\n   * @param actions The Secrets Manager actions to allow\n   * @returns PolicyStatement for Secrets Manager access\n   */\n  public static createSecretsManagerPolicyStatement(\n    secretArn: string,\n    actions: string[] = ['secretsmanager:GetSecretValue'],\n  ): iam.PolicyStatement {\n    return new iam.PolicyStatement({\n      effect: iam.Effect.ALLOW,\n      actions,\n      resources: [secretArn],\n    });\n  }\n\n  /**\n   * Creates a policy statement for KMS key access\n   *\n   * @param keyArn The ARN of the KMS key\n   * @param actions The KMS actions to allow\n   * @returns PolicyStatement for KMS access\n   */\n  public static createKmsPolicyStatement(\n    keyArn: string,\n    actions: string[] = ['kms:Decrypt', 'kms:GenerateDataKey'],\n  ): iam.PolicyStatement {\n    return new iam.PolicyStatement({\n      effect: iam.Effect.ALLOW,\n      actions,\n      resources: [keyArn],\n    });\n  }\n}\n"]}

package/lib/utilities/lambda_layers/data-masking/layer-construct.d.ts

@@ -0,0 +1,42 @@
+import * as lambda from 'aws-cdk-lib/aws-lambda';
+import { Construct } from 'constructs';
+/**
+ * Properties for the DataMaskingLayerConstruct
+ */
+export interface DataMaskingLayerProps {
+    /**
+     * Description for the Lambda layer
+     * @default 'Lambda layer for masking sensitive data in document processing'
+     */
+    description?: string;
+    /**
+     * Custom masking patterns to add to the default ones
+     * @default {}
+     */
+    customPatterns?: Record<string, {
+        /**
+         * Regular expression pattern as string
+         */
+        regex: string;
+        /**
+         * Mask to apply (string or function name)
+         */
+        mask: string;
+    }>;
+}
+/**
+ * Construct that creates a Lambda layer for data masking
+ */
+export declare class DataMaskingLayerConstruct extends Construct {
+    /**
+     * The Lambda layer containing masking utilities
+     */
+    readonly layer: lambda.LayerVersion;
+    constructor(scope: Construct, id: string, props?: DataMaskingLayerProps);
+    /**
+     * Adds the masking layer to a Lambda function
+     * @param fn Lambda function to add the layer to
+     * @param maskingConfig Optional masking configuration to add as environment variable
+     */
+    addToFunction(fn: lambda.Function, maskingConfig?: Record<string, string[]>): void;
+}

package/lib/utilities/lambda_layers/data-masking/layer-construct.js

@@ -0,0 +1,53 @@
+"use strict";
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DataMaskingLayerConstruct = void 0;
+const path = require("path");
+const lambda = require("aws-cdk-lib/aws-lambda");
+const constructs_1 = require("constructs");
+/**
+ * Construct that creates a Lambda layer for data masking
+ */
+class DataMaskingLayerConstruct extends constructs_1.Construct {
+    constructor(scope, id, props = {}) {
+        super(scope, id);
+        // Create the Lambda layer
+        this.layer = new lambda.LayerVersion(this, 'DataMaskingLayer', {
+            code: lambda.Code.fromAsset(path.join(__dirname, '../../../utilities/lambda_layers/data-masking')),
+            compatibleRuntimes: [
+                lambda.Runtime.NODEJS_16_X,
+                lambda.Runtime.NODEJS_18_X,
+                lambda.Runtime.NODEJS_20_X,
+            ],
+            description: props.description || 'Lambda layer for masking sensitive data',
+            license: 'Apache-2.0',
+        });
+        // Add metadata about available masking patterns
+        const defaultPatterns = [
+            'nric', 'ssn', 'creditCard', 'email', 'phone', 'passport',
+        ];
+        // Add custom patterns if provided
+        const allPatterns = [...defaultPatterns];
+        if (props.customPatterns) {
+            allPatterns.push(...Object.keys(props.customPatterns));
+        }
+        // Add metadata to the construct
+        this.node.addMetadata('maskingPatterns', allPatterns.join(', '));
+    }
+    /**
+     * Adds the masking layer to a Lambda function
+     * @param fn Lambda function to add the layer to
+     * @param maskingConfig Optional masking configuration to add as environment variable
+     */
+    addToFunction(fn, maskingConfig) {
+        // Add the layer to the function
+        fn.addLayers(this.layer);
+        // Add masking configuration if provided
+        if (maskingConfig) {
+            fn.addEnvironment('MASKING_CONFIG', JSON.stringify(maskingConfig));
+        }
+    }
+}
+exports.DataMaskingLayerConstruct = DataMaskingLayerConstruct;
+//# sourceMappingURL=data:application/json;base64,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

package/lib/utilities/lambda_layers/data-masking/layer-construct.ts

@@ -0,0 +1,88 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+import * as path from 'path';
+import * as lambda from 'aws-cdk-lib/aws-lambda';
+import { Construct } from 'constructs';
+
+/**
+ * Properties for the DataMaskingLayerConstruct
+ */
+export interface DataMaskingLayerProps {
+  /**
+   * Description for the Lambda layer
+   * @default 'Lambda layer for masking sensitive data in document processing'
+   */
+  description?: string;
+
+  /**
+   * Custom masking patterns to add to the default ones
+   * @default {}
+   */
+  customPatterns?: Record<string, {
+    /**
+     * Regular expression pattern as string
+     */
+    regex: string;
+
+    /**
+     * Mask to apply (string or function name)
+     */
+    mask: string;
+  }>;
+}
+
+/**
+ * Construct that creates a Lambda layer for data masking
+ */
+export class DataMaskingLayerConstruct extends Construct {
+  /**
+   * The Lambda layer containing masking utilities
+   */
+  public readonly layer: lambda.LayerVersion;
+
+  constructor(scope: Construct, id: string, props: DataMaskingLayerProps = {}) {
+    super(scope, id);
+
+    // Create the Lambda layer
+    this.layer = new lambda.LayerVersion(this, 'DataMaskingLayer', {
+      code: lambda.Code.fromAsset(path.join(__dirname, '../../../utilities/lambda_layers/data-masking')),
+      compatibleRuntimes: [
+        lambda.Runtime.NODEJS_16_X,
+        lambda.Runtime.NODEJS_18_X,
+        lambda.Runtime.NODEJS_20_X,
+      ],
+      description: props.description || 'Lambda layer for masking sensitive data',
+      license: 'Apache-2.0',
+    });
+
+    // Add metadata about available masking patterns
+    const defaultPatterns = [
+      'nric', 'ssn', 'creditCard', 'email', 'phone', 'passport',
+    ];
+
+    // Add custom patterns if provided
+    const allPatterns = [...defaultPatterns];
+    if (props.customPatterns) {
+      allPatterns.push(...Object.keys(props.customPatterns));
+    }
+
+    // Add metadata to the construct
+    this.node.addMetadata('maskingPatterns', allPatterns.join(', '));
+  }
+
+  /**
+   * Adds the masking layer to a Lambda function
+   * @param fn Lambda function to add the layer to
+   * @param maskingConfig Optional masking configuration to add as environment variable
+   */
+  public addToFunction(fn: lambda.Function, maskingConfig?: Record<string, string[]>): void {
+    // Add the layer to the function
+    fn.addLayers(this.layer);
+
+    // Add masking configuration if provided
+    if (maskingConfig) {
+      fn.addEnvironment('MASKING_CONFIG', JSON.stringify(maskingConfig));
+    }
+  }
+}

package/lib/utilities/observability/bedrock-observability.d.ts

@@ -0,0 +1,18 @@
+import { RemovalPolicy } from 'aws-cdk-lib';
+import { Role } from 'aws-cdk-lib/aws-iam';
+import { Key } from 'aws-cdk-lib/aws-kms';
+import { LogGroup } from 'aws-cdk-lib/aws-logs';
+import { Construct } from 'constructs';
+import { LogGroupDataProtectionProps } from './log-group-data-protection-props';
+export interface BedrockObservabilityProps {
+    readonly logGroupDataProtection?: LogGroupDataProtectionProps;
+    readonly loggingRole?: Role;
+    readonly overrideExistingConfiguration?: boolean;
+    readonly removalPolicy?: RemovalPolicy;
+}
+export declare class BedrockObservability extends Construct {
+    readonly logGroup: LogGroup;
+    readonly loggingRole: Role;
+    readonly encryptionKey: Key;
+    constructor(scope: Construct, id: string, props?: BedrockObservabilityProps);
+}