@aws-cdk/aws-elasticache-alpha 2.218.0-alpha.0

package/lib/serverless-cache.js

@@ -0,0 +1,429 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var _a;
+var ServerlessCache_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ServerlessCache = void 0;
+const jsiiDeprecationWarnings = require("../.warnings.jsii.js");
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const common_1 = require("./common");
+const aws_elasticache_1 = require("aws-cdk-lib/aws-elasticache");
+const serverless_cache_base_1 = require("./serverless-cache-base");
+const ec2 = require("aws-cdk-lib/aws-ec2");
+const core_1 = require("aws-cdk-lib/core");
+const metadata_resource_1 = require("aws-cdk-lib/core/lib/metadata-resource");
+const prop_injectable_1 = require("aws-cdk-lib/core/lib/prop-injectable");
+const ELASTICACHE_SERVERLESSCACHE_SYMBOL = Symbol.for('@aws-cdk/aws-elasticache.ServerlessCache');
+/**
+ * Unit types for data storage usage limits
+ */
+var DataStorageUnit;
+(function (DataStorageUnit) {
+    /**
+     * Gigabytes
+     */
+    DataStorageUnit["GIGABYTES"] = "GB";
+})(DataStorageUnit || (DataStorageUnit = {}));
+/**
+ * Minimum data storage size in GB for ServerlessCache
+ */
+const DATA_STORAGE_MIN_GB = 1;
+/**
+ * Maximum data storage size in GB for ServerlessCache
+ */
+const DATA_STORAGE_MAX_GB = 5000;
+/**
+ * Minimum request rate limit in ECPUs per second for ServerlessCache
+ */
+const REQUEST_RATE_MIN_ECPU = 1000;
+/**
+ * Maximum request rate limit in ECPUs per second for ServerlessCache
+ */
+const REQUEST_RATE_MAX_ECPU = 15000000;
+/**
+ * A serverless ElastiCache cache
+ *
+ * @resource AWS::ElastiCache::ServerlessCache
+ */
+let ServerlessCache = ServerlessCache_1 = class ServerlessCache extends serverless_cache_base_1.ServerlessCacheBase {
+    /**
+     * Return whether the given object is a `ServerlessCache`
+     */
+    static isServerlessCache(x) {
+        return x !== null && typeof (x) === 'object' && ELASTICACHE_SERVERLESSCACHE_SYMBOL in x;
+    }
+    /**
+     * Import an existing serverless cache by name
+     *
+     * @param scope The parent creating construct (usually `this`)
+     * @param id The construct's name
+     * @param serverlessCacheName The name of the existing serverless cache
+     */
+    static fromServerlessCacheName(scope, id, serverlessCacheName) {
+        return ServerlessCache_1.fromServerlessCacheAttributes(scope, id, { serverlessCacheName });
+    }
+    /**
+     * Import an existing serverless cache by ARN
+     *
+     * @param scope The parent creating construct (usually `this`)
+     * @param id The construct's name
+     * @param serverlessCacheArn The ARN of the existing serverless cache
+     */
+    static fromServerlessCacheArn(scope, id, serverlessCacheArn) {
+        return ServerlessCache_1.fromServerlessCacheAttributes(scope, id, { serverlessCacheArn });
+    }
+    /**
+     * Import an existing serverless cache using attributes
+     *
+     * @param scope The parent creating construct (usually `this`)
+     * @param id The construct's name
+     * @param attrs A `ServerlessCacheAttributes` object
+     */
+    static fromServerlessCacheAttributes(scope, id, attrs) {
+        try {
+            jsiiDeprecationWarnings._aws_cdk_aws_elasticache_alpha_ServerlessCacheAttributes(attrs);
+        }
+        catch (error) {
+            if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
+                Error.captureStackTrace(error, this.fromServerlessCacheAttributes);
+            }
+            throw error;
+        }
+        let name;
+        let arn;
+        const stack = core_1.Stack.of(scope);
+        if (attrs.serverlessCacheArn && attrs.serverlessCacheName) {
+            throw new core_1.ValidationError('Only one of serverlessCacheArn or serverlessCacheName can be provided.', scope);
+        }
+        if (attrs.serverlessCacheArn) {
+            arn = attrs.serverlessCacheArn;
+            const extractedServerlessCacheName = stack.splitArn(attrs.serverlessCacheArn, core_1.ArnFormat.SLASH_RESOURCE_NAME).resourceName;
+            if (!extractedServerlessCacheName) {
+                throw new core_1.ValidationError('Unable to extract serverless cache name from ARN.', scope);
+            }
+            name = extractedServerlessCacheName;
+        }
+        else if (attrs.serverlessCacheName) {
+            name = attrs.serverlessCacheName;
+            arn = stack.formatArn({
+                service: 'elasticache',
+                resource: 'serverlesscache',
+                resourceName: attrs.serverlessCacheName,
+            });
+        }
+        else {
+            throw new core_1.ValidationError('One of serverlessCacheName or serverlessCacheArn is required.', scope);
+        }
+        class Import extends serverless_cache_base_1.ServerlessCacheBase {
+            constructor(serverlessCacheArn, serverlessCacheName) {
+                super(scope, id);
+                this.engine = attrs.engine;
+                this.backupArnsToRestore = attrs.backupArnsToRestore;
+                this.kmsKey = attrs.kmsKey;
+                this.vpc = attrs.vpc;
+                this.subnets = attrs.subnets;
+                this.securityGroups = attrs.securityGroups;
+                this.userGroup = attrs.userGroup;
+                this.serverlessCacheArn = serverlessCacheArn;
+                this.serverlessCacheName = serverlessCacheName;
+                if (this.engine) {
+                    let defaultPort;
+                    switch (this.engine) {
+                        case serverless_cache_base_1.CacheEngine.VALKEY_LATEST:
+                        case serverless_cache_base_1.CacheEngine.VALKEY_7:
+                        case serverless_cache_base_1.CacheEngine.VALKEY_8:
+                        case serverless_cache_base_1.CacheEngine.REDIS_LATEST:
+                            // Document showing the default port
+                            // https://docs.aws.amazon.com/AmazonElastiCache/latest/dg/set-up.html#elasticache-install-grant-access-VPN
+                            defaultPort = ec2.Port.tcp(6379);
+                            break;
+                        case serverless_cache_base_1.CacheEngine.MEMCACHED_LATEST:
+                            // Document showing the default port
+                            // https://docs.aws.amazon.com/AmazonElastiCache/latest/dg/set-up.html#elasticache-install-grant-access-VPN
+                            defaultPort = ec2.Port.tcp(11211);
+                            break;
+                        default:
+                            throw new core_1.ValidationError(`Unsupported cache engine: ${this.engine}`, scope);
+                    }
+                    this.connections = new ec2.Connections({
+                        securityGroups: this.securityGroups,
+                        defaultPort: defaultPort,
+                    });
+                }
+                else {
+                    this.connections = new ec2.Connections({
+                        securityGroups: this.securityGroups,
+                    });
+                }
+            }
+        }
+        return new Import(arn, name);
+    }
+    constructor(scope, id, props) {
+        super(scope, id, {});
+        try {
+            jsiiDeprecationWarnings._aws_cdk_aws_elasticache_alpha_ServerlessCacheProps(props);
+        }
+        catch (error) {
+            if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
+                Error.captureStackTrace(error, ServerlessCache);
+            }
+            throw error;
+        }
+        // Enhanced CDK Analytics Telemetry
+        (0, metadata_resource_1.addConstructMetadata)(this, props);
+        this.engine = props.engine ?? serverless_cache_base_1.CacheEngine.VALKEY_LATEST;
+        this.serverlessCacheName = props.serverlessCacheName ?? core_1.Lazy.string({ produce: () => core_1.Names.uniqueId(this) });
+        this.kmsKey = props.kmsKey;
+        this.vpc = props.vpc;
+        this.userGroup = props.userGroup;
+        this.validateDescription(props.description);
+        this.validateDataStorageLimits(props.cacheUsageLimits);
+        this.validateRequestRateLimits(props.cacheUsageLimits);
+        this.validateBackupSettings(props.backup);
+        this.validateUserGroupCompatibility(this.engine, this.userGroup);
+        const subnetConfig = this.configureSubnets(props);
+        const subnetIds = subnetConfig.subnetIds;
+        this.subnets = subnetConfig.subnets;
+        const securityGroupConfig = this.configureSecurityGroups(props);
+        const securityGroupIds = securityGroupConfig.securityGroupIds;
+        this.securityGroups = securityGroupConfig.securityGroups;
+        const [engine, version] = this.engine.split('_');
+        const resource = new aws_elasticache_1.CfnServerlessCache(this, 'Resource', {
+            engine: engine,
+            majorEngineVersion: version,
+            serverlessCacheName: this.serverlessCacheName,
+            description: props.description,
+            cacheUsageLimits: this.renderCacheUsageLimits(props.cacheUsageLimits),
+            dailySnapshotTime: props.backup?.backupTime ? this.formatBackupTime(props.backup.backupTime) : undefined,
+            snapshotRetentionLimit: props.backup?.backupRetentionLimit,
+            finalSnapshotName: props.backup?.backupNameBeforeDeletion,
+            snapshotArnsToRestore: props.backup?.backupArnsToRestore,
+            kmsKeyId: props.kmsKey?.keyId,
+            subnetIds: subnetIds,
+            securityGroupIds: securityGroupIds,
+            userGroupId: props.userGroup?.userGroupName,
+        });
+        if (props.userGroup) {
+            const userGroupResource = props.userGroup.node.findChild('Resource');
+            resource.addDependency(userGroupResource);
+        }
+        this.backupArnsToRestore = resource.snapshotArnsToRestore;
+        this.serverlessCacheArn = resource.attrArn;
+        this.serverlessCacheEndpointAddress = resource.attrEndpointAddress;
+        this.serverlessCacheEndpointPort = resource.attrEndpointPort;
+        this.serverlessCacheReaderEndpointAddress = resource.attrReaderEndpointAddress;
+        this.serverlessCacheReaderEndpointPort = resource.attrReaderEndpointPort;
+        this.serverlessCacheStatus = resource.attrStatus;
+        this.connections = new ec2.Connections({
+            securityGroups: this.securityGroups,
+            defaultPort: ec2.Port.tcp(core_1.Lazy.number({ produce: () => parseInt(this.serverlessCacheEndpointPort) })),
+        });
+        Object.defineProperty(this, ELASTICACHE_SERVERLESSCACHE_SYMBOL, { value: true });
+    }
+    /**
+     * Validate description meets AWS requirements
+     *
+     * @param description The description to validate
+     */
+    validateDescription(description) {
+        if (!description || core_1.Token.isUnresolved(description))
+            return;
+        if (description.length > 255) {
+            throw new core_1.ValidationError(`Description must not exceed 255 characters, currently has ${description.length}`, this);
+        }
+        if (description.includes('<') || description.includes('>')) {
+            throw new core_1.ValidationError('Description must not contain < or > characters', this);
+        }
+    }
+    /**
+     * Validate data storage size limits
+     *
+     * @param limits The usage limits containing data storage settings
+     */
+    validateDataStorageLimits(limits) {
+        if (!limits)
+            return;
+        if (limits.dataStorageMinimumSize && !limits.dataStorageMinimumSize.isUnresolved() &&
+            (limits.dataStorageMinimumSize.toGibibytes() < DATA_STORAGE_MIN_GB || limits.dataStorageMinimumSize.toGibibytes() > DATA_STORAGE_MAX_GB)) {
+            throw new core_1.ValidationError('Data storage minimum must be between 1 and 5000 GB.', this);
+        }
+        if (limits.dataStorageMaximumSize && !limits.dataStorageMaximumSize.isUnresolved() &&
+            (limits.dataStorageMaximumSize.toGibibytes() < DATA_STORAGE_MIN_GB || limits.dataStorageMaximumSize.toGibibytes() > DATA_STORAGE_MAX_GB)) {
+            throw new core_1.ValidationError('Data storage maximum must be between 1 and 5000 GB.', this);
+        }
+        if (limits.dataStorageMinimumSize && limits.dataStorageMaximumSize &&
+            !limits.dataStorageMinimumSize.isUnresolved() && !limits.dataStorageMaximumSize.isUnresolved() &&
+            limits.dataStorageMinimumSize.toGibibytes() > limits.dataStorageMaximumSize.toGibibytes()) {
+            throw new core_1.ValidationError('Data storage minimum cannot be greater than maximum', this);
+        }
+    }
+    /**
+     * Validate request rate limits
+     *
+     * @param limits The usage limits containing request rate settings
+     */
+    validateRequestRateLimits(limits) {
+        if (!limits)
+            return;
+        if (limits.requestRateLimitMinimum !== undefined && !core_1.Token.isUnresolved(limits.requestRateLimitMinimum) &&
+            (limits.requestRateLimitMinimum < REQUEST_RATE_MIN_ECPU || limits.requestRateLimitMinimum > REQUEST_RATE_MAX_ECPU)) {
+            throw new core_1.ValidationError('Request rate minimum must be between 1,000 and 15,000,000 ECPUs per second', this);
+        }
+        if (limits.requestRateLimitMaximum !== undefined && !core_1.Token.isUnresolved(limits.requestRateLimitMaximum) &&
+            (limits.requestRateLimitMaximum < REQUEST_RATE_MIN_ECPU || limits.requestRateLimitMaximum > REQUEST_RATE_MAX_ECPU)) {
+            throw new core_1.ValidationError('Request rate maximum must be between 1,000 and 15,000,000 ECPUs per second', this);
+        }
+        if (!core_1.Token.isUnresolved(limits.requestRateLimitMinimum) && !core_1.Token.isUnresolved(limits.requestRateLimitMaximum) &&
+            limits.requestRateLimitMinimum !== undefined && limits.requestRateLimitMaximum !== undefined &&
+            limits.requestRateLimitMinimum > limits.requestRateLimitMaximum) {
+            throw new core_1.ValidationError('Request rate minimum cannot be greater than maximum', this);
+        }
+    }
+    /**
+     * Validate backup settings meet AWS requirements
+     *
+     * @param backup The backup settings to validate
+     */
+    validateBackupSettings(backup) {
+        if (!core_1.Token.isUnresolved(backup?.backupRetentionLimit) && backup?.backupRetentionLimit !== undefined) {
+            const limit = backup.backupRetentionLimit;
+            if (limit < 1 || limit > 35) {
+                throw new core_1.ValidationError('Backup retention limit must be between 1 and 35 days', this);
+            }
+        }
+        if (!core_1.Token.isUnresolved(backup?.backupNameBeforeDeletion) && backup?.backupNameBeforeDeletion !== undefined) {
+            const name = backup.backupNameBeforeDeletion;
+            if (!/^[a-zA-Z]/.test(name)) {
+                throw new core_1.ValidationError('Final backup name must begin with a letter', this);
+            }
+            if (!/^[a-zA-Z0-9-]+$/.test(name)) {
+                throw new core_1.ValidationError('Final backup name must contain only ASCII letters, digits, and hyphens', this);
+            }
+            if (name.endsWith('-')) {
+                throw new core_1.ValidationError('Final backup name must not end with a hyphen', this);
+            }
+            if (name.includes('--')) {
+                throw new core_1.ValidationError('Final backup name must not contain two consecutive hyphens', this);
+            }
+        }
+    }
+    /**
+     * Validate user group compatibility with cache engine
+     *
+     * @param engine The cache engine
+     * @param userGroup The user group to validate
+     */
+    validateUserGroupCompatibility(engine, userGroup) {
+        if (!userGroup)
+            return;
+        if (engine === serverless_cache_base_1.CacheEngine.MEMCACHED_LATEST) {
+            throw new core_1.ValidationError('User groups cannot be used with Memcached engines. Only Redis and Valkey engines support user groups.', this);
+        }
+        if (engine === serverless_cache_base_1.CacheEngine.REDIS_LATEST && userGroup.engine !== common_1.UserEngine.REDIS) {
+            throw new core_1.ValidationError('Redis cache can only use Redis user groups.', this);
+        }
+    }
+    /**
+     * Render cache usage limits for CloudFormation
+     *
+     * @param limits The usage limits to render
+     * @returns CloudFormation-compatible usage limits object or undefined
+     */
+    renderCacheUsageLimits(limits) {
+        if (!limits)
+            return undefined;
+        const cacheUsageLimits = {};
+        if (limits.dataStorageMinimumSize !== undefined || limits.dataStorageMaximumSize !== undefined) {
+            cacheUsageLimits.dataStorage = {
+                unit: DataStorageUnit.GIGABYTES,
+                ...(limits.dataStorageMinimumSize !== undefined && { minimum: limits.dataStorageMinimumSize.toGibibytes() }),
+                ...(limits.dataStorageMaximumSize !== undefined && { maximum: limits.dataStorageMaximumSize.toGibibytes() }),
+            };
+        }
+        if (limits.requestRateLimitMinimum !== undefined || limits.requestRateLimitMaximum !== undefined) {
+            cacheUsageLimits.ecpuPerSecond = {
+                ...(limits.requestRateLimitMinimum !== undefined && { minimum: limits.requestRateLimitMinimum }),
+                ...(limits.requestRateLimitMaximum !== undefined && { maximum: limits.requestRateLimitMaximum }),
+            };
+        }
+        return Object.keys(cacheUsageLimits).length > 0 ? cacheUsageLimits : undefined;
+    }
+    /**
+     * Configure subnets for the cache
+     *
+     * @param props The ServerlessCache properties
+     * @returns Object containing subnet IDs and subnet objects
+     */
+    configureSubnets(props) {
+        let selectedSubnets;
+        if (props.vpcSubnets) {
+            selectedSubnets = props.vpc.selectSubnets(props.vpcSubnets);
+        }
+        else {
+            selectedSubnets = props.vpc.selectSubnets({
+                subnetType: ec2.SubnetType.PRIVATE_WITH_EGRESS,
+            });
+        }
+        return {
+            subnetIds: selectedSubnets.subnetIds.length > 0 ? selectedSubnets.subnetIds : undefined,
+            subnets: selectedSubnets.subnets.length > 0 ? selectedSubnets.subnets : undefined,
+        };
+    }
+    /**
+     * Configure security groups for the cache
+     *
+     * @param props The ServerlessCache properties
+     * @returns Object containing security group IDs and security group objects
+     */
+    configureSecurityGroups(props) {
+        if (props.securityGroups && props.securityGroups.length > 0) {
+            return {
+                securityGroupIds: props.securityGroups.map(sg => sg.securityGroupId),
+                securityGroups: props.securityGroups,
+            };
+        }
+        else {
+            const newSecurityGroup = new ec2.SecurityGroup(this, 'SecurityGroup', {
+                description: `Security group for ${this.node.id} cache.`,
+                vpc: props.vpc,
+            });
+            return {
+                securityGroupIds: [newSecurityGroup.securityGroupId],
+                securityGroups: [newSecurityGroup],
+            };
+        }
+    }
+    /**
+     * Format schedule to HH:MM format for daily backups
+     *
+     * @param schedule The schedule to format
+     * @returns Time string in HH:MM format
+     */
+    formatBackupTime(schedule) {
+        const WILD_CARD = '*';
+        const [minuteExpression, hourExpression, dayExpression, monthExpression, weekDayExpression, yearExpression,] = schedule.expressionString.substr(5).slice(0, -1).split(' ');
+        if (dayExpression != WILD_CARD || monthExpression != WILD_CARD || yearExpression != WILD_CARD || weekDayExpression != '?') {
+            throw new core_1.ValidationError('For now, only daily backup time is available (supports just hour and minute). Day, month, year, and weekDay are not allowed', this);
+        }
+        const hour = hourExpression == WILD_CARD ? '0' : hourExpression;
+        const minute = minuteExpression == WILD_CARD ? '0' : minuteExpression;
+        return `${hour.padStart(2, '0')}:${minute.padStart(2, '0')}`;
+    }
+};
+exports.ServerlessCache = ServerlessCache;
+_a = JSII_RTTI_SYMBOL_1;
+ServerlessCache[_a] = { fqn: "@aws-cdk/aws-elasticache-alpha.ServerlessCache", version: "2.218.0-alpha.0" };
+/**
+ * Uniquely identifies this class.
+ */
+ServerlessCache.PROPERTY_INJECTION_ID = 'aws-cdk-lib.aws-elasticache.ServerlessCache';
+exports.ServerlessCache = ServerlessCache = ServerlessCache_1 = __decorate([
+    prop_injectable_1.propertyInjectable
+], ServerlessCache);
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"serverless-cache.js","sourceRoot":"","sources":["serverless-cache.ts"],"names":[],"mappings":"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","sourcesContent":["import { Construct } from 'constructs';\nimport { UserEngine } from './common';\nimport { CfnServerlessCache, CfnUserGroup } from 'aws-cdk-lib/aws-elasticache';\nimport { IServerlessCache, ServerlessCacheBase, CacheEngine } from './serverless-cache-base';\nimport { IUserGroup } from './user-group';\nimport * as ec2 from 'aws-cdk-lib/aws-ec2';\nimport * as events from 'aws-cdk-lib/aws-events';\nimport * as kms from 'aws-cdk-lib/aws-kms';\nimport { ArnFormat, Stack, Size, Lazy, ValidationError, Names, Token } from 'aws-cdk-lib/core';\nimport { addConstructMetadata } from 'aws-cdk-lib/core/lib/metadata-resource';\nimport { propertyInjectable } from 'aws-cdk-lib/core/lib/prop-injectable';\n\nconst ELASTICACHE_SERVERLESSCACHE_SYMBOL = Symbol.for('@aws-cdk/aws-elasticache.ServerlessCache');\n\n/**\n * Unit types for data storage usage limits\n */\nenum DataStorageUnit {\n  /**\n   * Gigabytes\n   */\n  GIGABYTES = 'GB',\n}\n\n/**\n * Minimum data storage size in GB for ServerlessCache\n */\nconst DATA_STORAGE_MIN_GB = 1;\n/**\n * Maximum data storage size in GB for ServerlessCache\n */\nconst DATA_STORAGE_MAX_GB = 5000;\n/**\n * Minimum request rate limit in ECPUs per second for ServerlessCache\n */\nconst REQUEST_RATE_MIN_ECPU = 1000;\n/**\n * Maximum request rate limit in ECPUs per second for ServerlessCache\n */\nconst REQUEST_RATE_MAX_ECPU = 15000000;\n\n/**\n * Usage limits configuration for ServerlessCache\n */\nexport interface CacheUsageLimitsProperty {\n  /**\n   * Minimum data storage size (1 GB)\n   *\n   * @default - No minimum limit\n   */\n  readonly dataStorageMinimumSize?: Size;\n  /**\n   * Maximum data storage size (5000 GB)\n   *\n   * @default - No maximum limit\n   */\n  readonly dataStorageMaximumSize?: Size;\n  /**\n   * Minimum request rate limit (1000 ECPUs per second)\n   *\n   * @default - No minimum limit\n   */\n  readonly requestRateLimitMinimum?: number;\n  /**\n   * Maximum request rate limit (15000000 ECPUs per second)\n   *\n   * @default - No maximum limit\n   */\n  readonly requestRateLimitMaximum?: number;\n}\n\n/**\n * Backup configuration for ServerlessCache\n */\nexport interface BackupSettings {\n  /**\n   * Automated daily backup UTC time\n   *\n   * @default - No automated backups\n   */\n  readonly backupTime?: events.Schedule;\n  /**\n   * Number of days to retain backups (1-35)\n   *\n   * @default - Backups are not retained\n   */\n  readonly backupRetentionLimit?: number;\n  /**\n   * Name for the final backup taken before deletion\n   *\n   * @default - No final backup\n   */\n  readonly backupNameBeforeDeletion?: string;\n  /**\n   * ARNs of backups from which to restore data into the new cache\n   *\n   * @default - Create a new cache with no existing data\n   */\n  readonly backupArnsToRestore?: string[];\n}\n\n/**\n * Properties for defining a ServerlessCache\n */\nexport interface ServerlessCacheProps {\n  /**\n   * The cache engine combined with the version\n   * Enum options: VALKEY_DEFAULT, VALKEY_7, VALKEY_8, REDIS_DEFAULT, MEMCACHED_DEFAULT\n   * The default options bring the latest versions available.\n   *\n   * @default when not provided, the default engine would be Valkey, latest version available (VALKEY_DEFAULT)\n   */\n  readonly engine?: CacheEngine;\n  /**\n   * Name for the serverless cache\n   *\n   * @default automatically generated name by Resource\n   */\n  readonly serverlessCacheName?: string;\n  /**\n   * A description for the cache\n   *\n   * @default - No description\n   */\n  readonly description?: string;\n  /**\n   * Usage limits for the cache\n   *\n   * @default - No usage limits\n   */\n  readonly cacheUsageLimits?: CacheUsageLimitsProperty;\n  /**\n   * Backup configuration\n   *\n   * @default - No backups configured\n   */\n  readonly backup?: BackupSettings;\n  /**\n   * KMS key for encryption\n   *\n   * @default - Service managed encryption (AWS owned KMS key)\n   */\n  readonly kmsKey?: kms.IKey;\n  /**\n   * The VPC to place the cache in\n   */\n  readonly vpc: ec2.IVpc;\n  /**\n   * Which subnets to place the cache in\n   *\n   * @default - Private subnets with egress\n   */\n  readonly vpcSubnets?: ec2.SubnetSelection;\n  /**\n   * Security groups for the cache\n   *\n   * @default - A new security group is created\n   */\n  readonly securityGroups?: ec2.ISecurityGroup[];\n  /**\n   * User group for access control\n   *\n   * @default - No user group\n   */\n  readonly userGroup?: IUserGroup;\n}\n\n/**\n * Attributes that can be specified when importing a ServerlessCache\n */\nexport interface ServerlessCacheAttributes {\n  /**\n   * The cache engine used by this cache\n   *\n   * @default - engine type is unknown\n   */\n  readonly engine?: CacheEngine;\n  /**\n   * The name of the serverless cache\n   *\n   * One of `serverlessCacheName` or `serverlessCacheArn` is required.\n   *\n   * @default - derived from serverlessCacheArn\n   */\n  readonly serverlessCacheName?: string;\n  /**\n   * The ARN of the serverless cache\n   *\n   * One of `serverlessCacheName` or `serverlessCacheArn` is required.\n   *\n   * @default - derived from serverlessCacheName\n   */\n  readonly serverlessCacheArn?: string;\n  /**\n   * The ARNs of backups restored in the cache\n   *\n   * @default - backups are unknown\n   */\n  readonly backupArnsToRestore?: string[];\n  /**\n   * The KMS key used for encryption\n   *\n   * @default - encryption key is unknown\n   */\n  readonly kmsKey?: kms.IKey;\n  /**\n   * The VPC this cache is deployed in\n   *\n   * @default - VPC is unknown\n   */\n  readonly vpc?: ec2.IVpc;\n  /**\n   * The subnets this cache is deployed in\n   *\n   * @default - subnets are unknown\n   */\n  readonly subnets?: ec2.ISubnet[];\n  /**\n   * The security groups associated with this cache\n   *\n   * @default - security groups are unknown\n   */\n  readonly securityGroups?: ec2.ISecurityGroup[];\n  /**\n   * The user group associated with this cache\n   *\n   * @default - user group is unknown\n   */\n  readonly userGroup?: IUserGroup;\n}\n\n/**\n * A serverless ElastiCache cache\n *\n * @resource AWS::ElastiCache::ServerlessCache\n */\n@propertyInjectable\nexport class ServerlessCache extends ServerlessCacheBase {\n  /**\n   * Uniquely identifies this class.\n   */\n  public static readonly PROPERTY_INJECTION_ID: string = 'aws-cdk-lib.aws-elasticache.ServerlessCache';\n\n  /**\n   * Return whether the given object is a `ServerlessCache`\n   */\n  public static isServerlessCache(x: any): x is ServerlessCache {\n    return x !== null && typeof (x) === 'object' && ELASTICACHE_SERVERLESSCACHE_SYMBOL in x;\n  }\n\n  /**\n   * Import an existing serverless cache by name\n   *\n   * @param scope The parent creating construct (usually `this`)\n   * @param id The construct's name\n   * @param serverlessCacheName The name of the existing serverless cache\n   */\n  public static fromServerlessCacheName(scope: Construct, id: string, serverlessCacheName: string): IServerlessCache {\n    return ServerlessCache.fromServerlessCacheAttributes(scope, id, { serverlessCacheName });\n  }\n\n  /**\n   * Import an existing serverless cache by ARN\n   *\n   * @param scope The parent creating construct (usually `this`)\n   * @param id The construct's name\n   * @param serverlessCacheArn The ARN of the existing serverless cache\n   */\n  public static fromServerlessCacheArn(scope: Construct, id: string, serverlessCacheArn: string): IServerlessCache {\n    return ServerlessCache.fromServerlessCacheAttributes(scope, id, { serverlessCacheArn });\n  }\n\n  /**\n   * Import an existing serverless cache using attributes\n   *\n   * @param scope The parent creating construct (usually `this`)\n   * @param id The construct's name\n   * @param attrs A `ServerlessCacheAttributes` object\n   */\n  public static fromServerlessCacheAttributes(scope: Construct, id: string, attrs: ServerlessCacheAttributes): IServerlessCache {\n    let name: string;\n    let arn: string;\n    const stack = Stack.of(scope);\n\n    if (attrs.serverlessCacheArn && attrs.serverlessCacheName) {\n      throw new ValidationError('Only one of serverlessCacheArn or serverlessCacheName can be provided.', scope);\n    }\n\n    if (attrs.serverlessCacheArn) {\n      arn = attrs.serverlessCacheArn;\n      const extractedServerlessCacheName = stack.splitArn(attrs.serverlessCacheArn, ArnFormat.SLASH_RESOURCE_NAME).resourceName;\n      if (!extractedServerlessCacheName) {\n        throw new ValidationError('Unable to extract serverless cache name from ARN.', scope);\n      }\n      name = extractedServerlessCacheName;\n    } else if (attrs.serverlessCacheName) {\n      name = attrs.serverlessCacheName;\n      arn = stack.formatArn({\n        service: 'elasticache',\n        resource: 'serverlesscache',\n        resourceName: attrs.serverlessCacheName,\n      });\n    } else {\n      throw new ValidationError('One of serverlessCacheName or serverlessCacheArn is required.', scope);\n    }\n\n    class Import extends ServerlessCacheBase {\n      public readonly engine = attrs.engine;\n      public readonly serverlessCacheName: string;\n      public readonly serverlessCacheArn: string;\n      public readonly backupArnsToRestore = attrs.backupArnsToRestore;\n      public readonly kmsKey = attrs.kmsKey;\n      public readonly vpc = attrs.vpc;\n      public readonly subnets = attrs.subnets;\n      public readonly securityGroups = attrs.securityGroups;\n      public readonly userGroup = attrs.userGroup;\n\n      public readonly connections: ec2.Connections;\n\n      constructor(serverlessCacheArn: string, serverlessCacheName: string) {\n        super(scope, id);\n        this.serverlessCacheArn = serverlessCacheArn;\n        this.serverlessCacheName = serverlessCacheName;\n\n        if (this.engine) {\n          let defaultPort: ec2.Port;\n          switch (this.engine) {\n            case CacheEngine.VALKEY_LATEST:\n            case CacheEngine.VALKEY_7:\n            case CacheEngine.VALKEY_8:\n            case CacheEngine.REDIS_LATEST:\n              // Document showing the default port\n              // https://docs.aws.amazon.com/AmazonElastiCache/latest/dg/set-up.html#elasticache-install-grant-access-VPN\n              defaultPort = ec2.Port.tcp(6379);\n              break;\n            case CacheEngine.MEMCACHED_LATEST:\n              // Document showing the default port\n              // https://docs.aws.amazon.com/AmazonElastiCache/latest/dg/set-up.html#elasticache-install-grant-access-VPN\n              defaultPort = ec2.Port.tcp(11211);\n              break;\n            default:\n              throw new ValidationError(`Unsupported cache engine: ${this.engine}`, scope);\n          }\n\n          this.connections = new ec2.Connections({\n            securityGroups: this.securityGroups,\n            defaultPort: defaultPort,\n          });\n        } else {\n          this.connections = new ec2.Connections({\n            securityGroups: this.securityGroups,\n          });\n        }\n      }\n    }\n\n    return new Import(arn, name);\n  }\n\n  public readonly engine?: CacheEngine;\n  public readonly serverlessCacheName: string;\n  public readonly backupArnsToRestore?: string[];\n  public readonly kmsKey?: kms.IKey;\n  public readonly vpc?: ec2.IVpc;\n  public readonly subnets?: ec2.ISubnet[];\n  public readonly securityGroups?: ec2.ISecurityGroup[];\n  public readonly userGroup?: IUserGroup;\n\n  /**\n   * The ARN of the serverless cache\n   *\n   * @attribute\n   */\n  public readonly serverlessCacheArn: string;\n  /**\n   * The endpoint address of the serverless cache\n   *\n   * @attribute\n   */\n  public readonly serverlessCacheEndpointAddress: string;\n  /**\n   * The endpoint port of the serverless cache\n   *\n   * @attribute\n   */\n  public readonly serverlessCacheEndpointPort: string;\n  /**\n   * The reader endpoint address of the serverless cache\n   *\n   * @attribute\n   */\n  public readonly serverlessCacheReaderEndpointAddress: string;\n  /**\n   * The reader endpoint port of the serverless cache\n   *\n   * @attribute\n   */\n  public readonly serverlessCacheReaderEndpointPort: string;\n  /**\n   * The current status of the serverless cache\n   * Can be 'CREATING', 'AVAILABLE', 'DELETING', 'CREATE-FAILED', 'MODIFYING'\n   *\n   * @attribute\n   */\n  public readonly serverlessCacheStatus: string;\n\n  /**\n   * Access to network connections\n   */\n  public readonly connections: ec2.Connections;\n\n  constructor(scope: Construct, id: string, props: ServerlessCacheProps) {\n    super(scope, id, {});\n\n    // Enhanced CDK Analytics Telemetry\n    addConstructMetadata(this, props);\n\n    this.engine = props.engine ?? CacheEngine.VALKEY_LATEST;\n    this.serverlessCacheName = props.serverlessCacheName ?? Lazy.string({ produce: () => Names.uniqueId(this) });\n    this.kmsKey = props.kmsKey;\n    this.vpc = props.vpc;\n    this.userGroup = props.userGroup;\n\n    this.validateDescription(props.description);\n    this.validateDataStorageLimits(props.cacheUsageLimits);\n    this.validateRequestRateLimits(props.cacheUsageLimits);\n    this.validateBackupSettings(props.backup);\n    this.validateUserGroupCompatibility(this.engine, this.userGroup);\n\n    const subnetConfig = this.configureSubnets(props);\n    const subnetIds = subnetConfig.subnetIds;\n    this.subnets = subnetConfig.subnets;\n\n    const securityGroupConfig = this.configureSecurityGroups(props);\n    const securityGroupIds = securityGroupConfig.securityGroupIds;\n    this.securityGroups = securityGroupConfig.securityGroups;\n\n    const [engine, version] = this.engine.split('_');\n\n    const resource = new CfnServerlessCache(this, 'Resource', {\n      engine: engine,\n      majorEngineVersion: version,\n      serverlessCacheName: this.serverlessCacheName,\n      description: props.description,\n      cacheUsageLimits: this.renderCacheUsageLimits(props.cacheUsageLimits),\n      dailySnapshotTime: props.backup?.backupTime ? this.formatBackupTime(props.backup.backupTime) : undefined,\n      snapshotRetentionLimit: props.backup?.backupRetentionLimit,\n      finalSnapshotName: props.backup?.backupNameBeforeDeletion,\n      snapshotArnsToRestore: props.backup?.backupArnsToRestore,\n      kmsKeyId: props.kmsKey?.keyId,\n      subnetIds: subnetIds,\n      securityGroupIds: securityGroupIds,\n      userGroupId: props.userGroup?.userGroupName,\n    });\n\n    if (props.userGroup) {\n      const userGroupResource = props.userGroup.node.findChild('Resource') as CfnUserGroup;\n      resource.addDependency(userGroupResource);\n    }\n\n    this.backupArnsToRestore = resource.snapshotArnsToRestore;\n    this.serverlessCacheArn = resource.attrArn;\n    this.serverlessCacheEndpointAddress = resource.attrEndpointAddress;\n    this.serverlessCacheEndpointPort = resource.attrEndpointPort;\n    this.serverlessCacheReaderEndpointAddress = resource.attrReaderEndpointAddress;\n    this.serverlessCacheReaderEndpointPort = resource.attrReaderEndpointPort;\n    this.serverlessCacheStatus = resource.attrStatus;\n\n    this.connections = new ec2.Connections({\n      securityGroups: this.securityGroups,\n      defaultPort: ec2.Port.tcp(Lazy.number({ produce: () => parseInt(this.serverlessCacheEndpointPort) })),\n    });\n\n    Object.defineProperty(this, ELASTICACHE_SERVERLESSCACHE_SYMBOL, { value: true });\n  }\n\n  /**\n   * Validate description meets AWS requirements\n   *\n   * @param description The description to validate\n   */\n  private validateDescription(description?: string): void {\n    if (!description || Token.isUnresolved(description)) return;\n\n    if (description.length > 255) {\n      throw new ValidationError(`Description must not exceed 255 characters, currently has ${description.length}`, this);\n    }\n\n    if (description.includes('<') || description.includes('>')) {\n      throw new ValidationError('Description must not contain < or > characters', this);\n    }\n  }\n\n  /**\n   * Validate data storage size limits\n   *\n   * @param limits The usage limits containing data storage settings\n   */\n  private validateDataStorageLimits(limits?: CacheUsageLimitsProperty): void {\n    if (!limits) return;\n\n    if (limits.dataStorageMinimumSize && !limits.dataStorageMinimumSize.isUnresolved() &&\n      (limits.dataStorageMinimumSize.toGibibytes() < DATA_STORAGE_MIN_GB || limits.dataStorageMinimumSize.toGibibytes() > DATA_STORAGE_MAX_GB)) {\n      throw new ValidationError('Data storage minimum must be between 1 and 5000 GB.', this);\n    }\n    if (limits.dataStorageMaximumSize && !limits.dataStorageMaximumSize.isUnresolved() &&\n      (limits.dataStorageMaximumSize.toGibibytes() < DATA_STORAGE_MIN_GB || limits.dataStorageMaximumSize.toGibibytes() > DATA_STORAGE_MAX_GB)) {\n      throw new ValidationError('Data storage maximum must be between 1 and 5000 GB.', this);\n    }\n\n    if (limits.dataStorageMinimumSize && limits.dataStorageMaximumSize &&\n      !limits.dataStorageMinimumSize.isUnresolved() && !limits.dataStorageMaximumSize.isUnresolved() &&\n      limits.dataStorageMinimumSize.toGibibytes() > limits.dataStorageMaximumSize.toGibibytes()) {\n      throw new ValidationError('Data storage minimum cannot be greater than maximum', this);\n    }\n  }\n\n  /**\n   * Validate request rate limits\n   *\n   * @param limits The usage limits containing request rate settings\n   */\n  private validateRequestRateLimits(limits?: CacheUsageLimitsProperty): void {\n    if (!limits) return;\n\n    if (limits.requestRateLimitMinimum !== undefined && !Token.isUnresolved(limits.requestRateLimitMinimum) &&\n      (limits.requestRateLimitMinimum < REQUEST_RATE_MIN_ECPU || limits.requestRateLimitMinimum > REQUEST_RATE_MAX_ECPU)) {\n      throw new ValidationError('Request rate minimum must be between 1,000 and 15,000,000 ECPUs per second', this);\n    }\n    if (limits.requestRateLimitMaximum !== undefined && !Token.isUnresolved(limits.requestRateLimitMaximum) &&\n      (limits.requestRateLimitMaximum < REQUEST_RATE_MIN_ECPU || limits.requestRateLimitMaximum > REQUEST_RATE_MAX_ECPU)) {\n      throw new ValidationError('Request rate maximum must be between 1,000 and 15,000,000 ECPUs per second', this);\n    }\n\n    if (!Token.isUnresolved(limits.requestRateLimitMinimum) && !Token.isUnresolved(limits.requestRateLimitMaximum) &&\n      limits.requestRateLimitMinimum !== undefined && limits.requestRateLimitMaximum !== undefined &&\n      limits.requestRateLimitMinimum > limits.requestRateLimitMaximum) {\n      throw new ValidationError('Request rate minimum cannot be greater than maximum', this);\n    }\n  }\n\n  /**\n   * Validate backup settings meet AWS requirements\n   *\n   * @param backup The backup settings to validate\n   */\n  private validateBackupSettings(backup?: BackupSettings): void {\n    if (!Token.isUnresolved(backup?.backupRetentionLimit) && backup?.backupRetentionLimit !== undefined) {\n      const limit = backup.backupRetentionLimit;\n      if (limit < 1 || limit > 35) {\n        throw new ValidationError('Backup retention limit must be between 1 and 35 days', this);\n      }\n    }\n\n    if (!Token.isUnresolved(backup?.backupNameBeforeDeletion) && backup?.backupNameBeforeDeletion !== undefined) {\n      const name = backup.backupNameBeforeDeletion;\n\n      if (!/^[a-zA-Z]/.test(name)) {\n        throw new ValidationError('Final backup name must begin with a letter', this);\n      }\n\n      if (!/^[a-zA-Z0-9-]+$/.test(name)) {\n        throw new ValidationError('Final backup name must contain only ASCII letters, digits, and hyphens', this);\n      }\n\n      if (name.endsWith('-')) {\n        throw new ValidationError('Final backup name must not end with a hyphen', this);\n      }\n\n      if (name.includes('--')) {\n        throw new ValidationError('Final backup name must not contain two consecutive hyphens', this);\n      }\n    }\n  }\n\n  /**\n   * Validate user group compatibility with cache engine\n   *\n   * @param engine The cache engine\n   * @param userGroup The user group to validate\n   */\n  private validateUserGroupCompatibility(engine: CacheEngine, userGroup?: IUserGroup): void {\n    if (!userGroup) return;\n\n    if (engine === CacheEngine.MEMCACHED_LATEST) {\n      throw new ValidationError('User groups cannot be used with Memcached engines. Only Redis and Valkey engines support user groups.', this);\n    }\n\n    if (engine === CacheEngine.REDIS_LATEST && userGroup.engine !== UserEngine.REDIS) {\n      throw new ValidationError('Redis cache can only use Redis user groups.', this);\n    }\n  }\n\n  /**\n   * Render cache usage limits for CloudFormation\n   *\n   * @param limits The usage limits to render\n   * @returns CloudFormation-compatible usage limits object or undefined\n   */\n  private renderCacheUsageLimits(limits?: CacheUsageLimitsProperty): any {\n    if (!limits) return undefined;\n\n    const cacheUsageLimits: any = {};\n\n    if (limits.dataStorageMinimumSize !== undefined || limits.dataStorageMaximumSize !== undefined) {\n      cacheUsageLimits.dataStorage = {\n        unit: DataStorageUnit.GIGABYTES,\n        ...(limits.dataStorageMinimumSize !== undefined && { minimum: limits.dataStorageMinimumSize.toGibibytes() }),\n        ...(limits.dataStorageMaximumSize !== undefined && { maximum: limits.dataStorageMaximumSize.toGibibytes() }),\n      };\n    }\n\n    if (limits.requestRateLimitMinimum !== undefined || limits.requestRateLimitMaximum !== undefined) {\n      cacheUsageLimits.ecpuPerSecond = {\n        ...(limits.requestRateLimitMinimum !== undefined && { minimum: limits.requestRateLimitMinimum }),\n        ...(limits.requestRateLimitMaximum !== undefined && { maximum: limits.requestRateLimitMaximum }),\n      };\n    }\n\n    return Object.keys(cacheUsageLimits).length > 0 ? cacheUsageLimits : undefined;\n  }\n\n  /**\n   * Configure subnets for the cache\n   *\n   * @param props The ServerlessCache properties\n   * @returns Object containing subnet IDs and subnet objects\n   */\n  private configureSubnets(props: ServerlessCacheProps): { subnetIds: string[] | undefined; subnets: ec2.ISubnet[] | undefined } {\n    let selectedSubnets;\n    if (props.vpcSubnets) {\n      selectedSubnets = props.vpc.selectSubnets(props.vpcSubnets);\n    } else {\n      selectedSubnets = props.vpc.selectSubnets({\n        subnetType: ec2.SubnetType.PRIVATE_WITH_EGRESS,\n      });\n    }\n\n    return {\n      subnetIds: selectedSubnets.subnetIds.length > 0 ? selectedSubnets.subnetIds : undefined,\n      subnets: selectedSubnets.subnets.length > 0 ? selectedSubnets.subnets : undefined,\n    };\n  }\n\n  /**\n   * Configure security groups for the cache\n   *\n   * @param props The ServerlessCache properties\n   * @returns Object containing security group IDs and security group objects\n   */\n  private configureSecurityGroups(props: ServerlessCacheProps): { securityGroupIds: string[]; securityGroups: ec2.ISecurityGroup[] } {\n    if (props.securityGroups && props.securityGroups.length > 0) {\n      return {\n        securityGroupIds: props.securityGroups.map(sg => sg.securityGroupId),\n        securityGroups: props.securityGroups,\n      };\n    } else {\n      const newSecurityGroup = new ec2.SecurityGroup(this, 'SecurityGroup', {\n        description: `Security group for ${this.node.id} cache.`,\n        vpc: props.vpc,\n      });\n      return {\n        securityGroupIds: [newSecurityGroup.securityGroupId],\n        securityGroups: [newSecurityGroup],\n      };\n    }\n  }\n\n  /**\n   * Format schedule to HH:MM format for daily backups\n   *\n   * @param schedule The schedule to format\n   * @returns Time string in HH:MM format\n   */\n  private formatBackupTime(schedule: events.Schedule): string {\n    const WILD_CARD = '*';\n    const [\n      minuteExpression, hourExpression,\n      dayExpression, monthExpression,\n      weekDayExpression, yearExpression,\n    ] = schedule.expressionString.substr(5).slice(0, -1).split(' ');\n\n    if (dayExpression != WILD_CARD || monthExpression != WILD_CARD || yearExpression != WILD_CARD || weekDayExpression != '?') {\n      throw new ValidationError('For now, only daily backup time is available (supports just hour and minute). Day, month, year, and weekDay are not allowed', this);\n    }\n\n    const hour = hourExpression == WILD_CARD ? '0' : hourExpression;\n    const minute = minuteExpression == WILD_CARD ? '0' : minuteExpression;\n\n    return `${hour.padStart(2, '0')}:${minute.padStart(2, '0')}`;\n  }\n}\n"]}