@aws-cdk/aws-bedrock-agentcore-alpha 2.250.0-alpha.0 → 2.252.0-alpha.0

package/lib/policy/validation-helpers.js

@@ -0,0 +1,276 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TAG_VALUE_PATTERN = exports.TAG_KEY_PATTERN = exports.TAG_VALUE_MAX_LENGTH = exports.TAG_KEY_MAX_LENGTH = exports.TAG_KEY_MIN_LENGTH = exports.MAX_TAGS = exports.DESCRIPTION_MAX_LENGTH = exports.POLICY_DEFINITION_MAX_LENGTH = exports.POLICY_DEFINITION_MIN_LENGTH = exports.POLICY_NAME_PATTERN = exports.POLICY_NAME_MAX_LENGTH = exports.POLICY_NAME_MIN_LENGTH = exports.POLICY_ENGINE_NAME_PATTERN = exports.POLICY_ENGINE_NAME_MAX_LENGTH = exports.POLICY_ENGINE_NAME_MIN_LENGTH = void 0;
+exports.validatePolicyEngineName = validatePolicyEngineName;
+exports.validatePolicyName = validatePolicyName;
+exports.validatePolicyDefinition = validatePolicyDefinition;
+exports.validateDescription = validateDescription;
+exports.throwIfInvalidPolicyEngineName = throwIfInvalidPolicyEngineName;
+exports.throwIfInvalidPolicyName = throwIfInvalidPolicyName;
+exports.throwIfInvalidPolicyDefinition = throwIfInvalidPolicyDefinition;
+exports.throwIfInvalidDescription = throwIfInvalidDescription;
+exports.validateTags = validateTags;
+exports.throwIfInvalidTags = throwIfInvalidTags;
+const aws_cdk_lib_1 = require("aws-cdk-lib");
+const validation_helpers_1 = require("../memory/validation-helpers");
+/**
+ * Validation constants for PolicyEngine
+ */
+exports.POLICY_ENGINE_NAME_MIN_LENGTH = 1;
+exports.POLICY_ENGINE_NAME_MAX_LENGTH = 48;
+exports.POLICY_ENGINE_NAME_PATTERN = /^[A-Za-z][A-Za-z0-9_]*$/;
+/**
+ * Validation constants for Policy
+ */
+exports.POLICY_NAME_MIN_LENGTH = 1;
+exports.POLICY_NAME_MAX_LENGTH = 48;
+exports.POLICY_NAME_PATTERN = /^[A-Za-z][A-Za-z0-9_]*$/;
+/**
+ * Validation constants for Cedar policy definitions
+ */
+exports.POLICY_DEFINITION_MIN_LENGTH = 35;
+exports.POLICY_DEFINITION_MAX_LENGTH = 153600;
+/**
+ * Validation constants for descriptions
+ */
+exports.DESCRIPTION_MAX_LENGTH = 4096;
+/**
+ * Validation constants for tags
+ */
+exports.MAX_TAGS = 50;
+exports.TAG_KEY_MIN_LENGTH = 1;
+exports.TAG_KEY_MAX_LENGTH = 128;
+exports.TAG_VALUE_MAX_LENGTH = 256;
+exports.TAG_KEY_PATTERN = /^[a-zA-Z0-9\s._:/=+@-]+$/;
+exports.TAG_VALUE_PATTERN = /^[a-zA-Z0-9\s._:/=+@-]*$/;
+/**
+ * Validates a policy engine name.
+ * Names must:
+ * - Start with a letter (a-z, A-Z)
+ * - Contain only letters, numbers, and underscores
+ * - Be between 1 and 48 characters
+ *
+ * @param name - The policy engine name to validate
+ * @param scope - The construct scope for error reporting (optional)
+ * @returns Array of validation error messages, empty if valid
+ */
+function validatePolicyEngineName(name, scope) {
+    const errors = [];
+    // Handle null/undefined values
+    if (name == null) {
+        return errors;
+    }
+    // Skip validation for unresolved tokens (e.g. Lazy.string(), cross-stack refs)
+    if (aws_cdk_lib_1.Token.isUnresolved(name)) {
+        return errors;
+    }
+    // Validate length
+    errors.push(...(0, validation_helpers_1.validateStringFieldLength)({
+        value: name,
+        fieldName: 'policyEngineName',
+        minLength: exports.POLICY_ENGINE_NAME_MIN_LENGTH,
+        maxLength: exports.POLICY_ENGINE_NAME_MAX_LENGTH,
+    }, scope));
+    // Validate pattern
+    errors.push(...(0, validation_helpers_1.validateFieldPattern)(name, 'policyEngineName', exports.POLICY_ENGINE_NAME_PATTERN, `The policy engine name "${name}" must start with a letter and contain only letters, numbers, and underscores`, scope));
+    return errors;
+}
+/**
+ * Validates a policy name.
+ * Names must:
+ * - Start with a letter (a-z, A-Z)
+ * - Contain only letters, numbers, and underscores
+ * - Be between 1 and 48 characters
+ *
+ * @param name - The policy name to validate
+ * @param scope - The construct scope for error reporting (optional)
+ * @returns Array of validation error messages, empty if valid
+ */
+function validatePolicyName(name, scope) {
+    const errors = [];
+    // Handle null/undefined values
+    if (name == null) {
+        return errors;
+    }
+    // Skip validation for unresolved tokens (e.g. Lazy.string(), cross-stack refs)
+    if (aws_cdk_lib_1.Token.isUnresolved(name)) {
+        return errors;
+    }
+    // Validate length
+    errors.push(...(0, validation_helpers_1.validateStringFieldLength)({
+        value: name,
+        fieldName: 'policyName',
+        minLength: exports.POLICY_NAME_MIN_LENGTH,
+        maxLength: exports.POLICY_NAME_MAX_LENGTH,
+    }, scope));
+    // Validate pattern
+    errors.push(...(0, validation_helpers_1.validateFieldPattern)(name, 'policyName', exports.POLICY_NAME_PATTERN, `The policy name "${name}" must start with a letter and contain only letters, numbers, and underscores`, scope));
+    return errors;
+}
+/**
+ * Validates a Cedar policy definition string.
+ * Definitions must be between 35 and 153,600 characters.
+ *
+ * @param definition - The Cedar policy definition to validate
+ * @param scope - The construct scope for error reporting (optional)
+ * @returns Array of validation error messages, empty if valid
+ */
+function validatePolicyDefinition(definition, scope) {
+    const errors = [];
+    // Handle null/undefined values
+    if (definition == null) {
+        errors.push('Policy definition is required and cannot be null or undefined');
+        return errors;
+    }
+    // Skip validation for unresolved tokens (e.g. Lazy.string(), cross-stack refs)
+    if (aws_cdk_lib_1.Token.isUnresolved(definition)) {
+        return errors;
+    }
+    // Validate length
+    errors.push(...(0, validation_helpers_1.validateStringFieldLength)({
+        value: definition,
+        fieldName: 'definition',
+        minLength: exports.POLICY_DEFINITION_MIN_LENGTH,
+        maxLength: exports.POLICY_DEFINITION_MAX_LENGTH,
+    }, scope));
+    return errors;
+}
+/**
+ * Validates a description string.
+ * Descriptions must not exceed 4,096 characters.
+ *
+ * @param description - The description to validate
+ * @param scope - The construct scope for error reporting (optional)
+ * @returns Array of validation error messages, empty if valid
+ */
+function validateDescription(description, scope) {
+    const errors = [];
+    // Handle null/undefined values
+    if (description == null) {
+        return errors;
+    }
+    // Skip validation for unresolved tokens (e.g. Lazy.string(), cross-stack refs)
+    if (aws_cdk_lib_1.Token.isUnresolved(description)) {
+        return errors;
+    }
+    // Validate length (no minimum length requirement)
+    errors.push(...(0, validation_helpers_1.validateStringFieldLength)({
+        value: description,
+        fieldName: 'description',
+        minLength: 0,
+        maxLength: exports.DESCRIPTION_MAX_LENGTH,
+    }, scope));
+    return errors;
+}
+/**
+ * Validates a policy engine name and throws if invalid.
+ *
+ * @param name - The policy engine name to validate
+ * @param scope - The construct scope for error reporting (optional)
+ * @returns The validated name
+ * @throws ValidationError if validation fails
+ */
+function throwIfInvalidPolicyEngineName(name, scope) {
+    return (0, validation_helpers_1.throwIfInvalid)(validatePolicyEngineName, name, scope);
+}
+/**
+ * Validates a policy name and throws if invalid.
+ *
+ * @param name - The policy name to validate
+ * @param scope - The construct scope for error reporting (optional)
+ * @returns The validated name
+ * @throws ValidationError if validation fails
+ */
+function throwIfInvalidPolicyName(name, scope) {
+    return (0, validation_helpers_1.throwIfInvalid)(validatePolicyName, name, scope);
+}
+/**
+ * Validates a policy definition and throws if invalid.
+ *
+ * @param definition - The Cedar policy definition to validate
+ * @param scope - The construct scope for error reporting (optional)
+ * @returns The validated definition
+ * @throws ValidationError if validation fails
+ */
+function throwIfInvalidPolicyDefinition(definition, scope) {
+    return (0, validation_helpers_1.throwIfInvalid)(validatePolicyDefinition, definition, scope);
+}
+/**
+ * Validates a description and throws if invalid.
+ *
+ * @param description - The description to validate
+ * @param scope - The construct scope for error reporting (optional)
+ * @returns The validated description
+ * @throws ValidationError if validation fails
+ */
+function throwIfInvalidDescription(description, scope) {
+    return (0, validation_helpers_1.throwIfInvalid)(validateDescription, description, scope);
+}
+/**
+ * Validates tags for a PolicyEngine.
+ * Tags must:
+ * - Not exceed 50 tags
+ * - Have keys between 1 and 128 characters
+ * - Have values between 0 and 256 characters
+ * - Match allowed character patterns
+ *
+ * @param tags - The tags object to validate
+ * @param resourceName - The name of the resource being tagged (for error messages)
+ * @param scope - The construct scope for error reporting (optional)
+ * @returns Array of validation error messages, empty if valid
+ */
+function validateTags(tags, resourceName, _scope) {
+    const errors = [];
+    // Handle null/undefined values
+    if (tags == null) {
+        return errors;
+    }
+    // Validate tag count
+    const tagCount = Object.keys(tags).length;
+    if (tagCount > exports.MAX_TAGS) {
+        errors.push(`PolicyEngine '${resourceName}' cannot have more than ${exports.MAX_TAGS} tags. Found: ${tagCount}`);
+    }
+    // Validate each tag
+    for (const [key, value] of Object.entries(tags)) {
+        // Skip validation for unresolved token keys
+        if (!aws_cdk_lib_1.Token.isUnresolved(key)) {
+            // Validate key length
+            if (key.length < exports.TAG_KEY_MIN_LENGTH || key.length > exports.TAG_KEY_MAX_LENGTH) {
+                errors.push(`PolicyEngine '${resourceName}' tag key length must be between ${exports.TAG_KEY_MIN_LENGTH} and ${exports.TAG_KEY_MAX_LENGTH} characters. ` +
+                    `Key: "${key}" has length ${key.length}`);
+            }
+            // Validate key pattern
+            if (!exports.TAG_KEY_PATTERN.test(key)) {
+                errors.push(`PolicyEngine '${resourceName}' tag key contains invalid characters. ` +
+                    `Key: "${key}". Valid characters: a-zA-Z0-9 and ._:/=+@-`);
+            }
+        }
+        // Skip validation for unresolved token values
+        if (!aws_cdk_lib_1.Token.isUnresolved(value)) {
+            // Validate value length
+            if (value.length > exports.TAG_VALUE_MAX_LENGTH) {
+                errors.push(`PolicyEngine '${resourceName}' tag value length cannot exceed ${exports.TAG_VALUE_MAX_LENGTH} characters. ` +
+                    `Key: "${key}", value has length ${value.length}`);
+            }
+            // Validate value pattern
+            if (!exports.TAG_VALUE_PATTERN.test(value)) {
+                errors.push(`PolicyEngine '${resourceName}' tag value contains invalid characters. ` +
+                    `Key: "${key}", Value: "${value}". Valid characters: a-zA-Z0-9 and ._:/=+@-`);
+            }
+        }
+    }
+    return errors;
+}
+/**
+ * Validates tags and throws if invalid.
+ *
+ * @param tags - The tags object to validate
+ * @param resourceName - The name of the resource being tagged (for error messages)
+ * @param scope - The construct scope for error reporting (optional)
+ * @returns The validated tags
+ * @throws ValidationError if validation fails
+ */
+function throwIfInvalidTags(tags, resourceName, scope) {
+    return (0, validation_helpers_1.throwIfInvalid)((t, s) => validateTags(t, resourceName, s), tags, scope);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"validation-helpers.js","sourceRoot":"","sources":["validation-helpers.ts"],"names":[],"mappings":";;;AAuDA,4DAsCC;AAaD,gDAsCC;AAUD,4DA4BC;AAUD,kDA2BC;AAUD,wEAEC;AAUD,4DAEC;AAUD,wEAEC;AAUD,8DAEC;AAeD,oCA8DC;AAWD,gDAUC;AA7WD,6CAAoC;AAEpC,qEAKsC;AAEtC;;GAEG;AACU,QAAA,6BAA6B,GAAG,CAAC,CAAC;AAClC,QAAA,6BAA6B,GAAG,EAAE,CAAC;AACnC,QAAA,0BAA0B,GAAG,yBAAyB,CAAC;AAEpE;;GAEG;AACU,QAAA,sBAAsB,GAAG,CAAC,CAAC;AAC3B,QAAA,sBAAsB,GAAG,EAAE,CAAC;AAC5B,QAAA,mBAAmB,GAAG,yBAAyB,CAAC;AAE7D;;GAEG;AACU,QAAA,4BAA4B,GAAG,EAAE,CAAC;AAClC,QAAA,4BAA4B,GAAG,MAAM,CAAC;AAEnD;;GAEG;AACU,QAAA,sBAAsB,GAAG,IAAI,CAAC;AAE3C;;GAEG;AACU,QAAA,QAAQ,GAAG,EAAE,CAAC;AACd,QAAA,kBAAkB,GAAG,CAAC,CAAC;AACvB,QAAA,kBAAkB,GAAG,GAAG,CAAC;AACzB,QAAA,oBAAoB,GAAG,GAAG,CAAC;AAC3B,QAAA,eAAe,GAAG,0BAA0B,CAAC;AAC7C,QAAA,iBAAiB,GAAG,0BAA0B,CAAC;AAE5D;;;;;;;;;;GAUG;AACH,SAAgB,wBAAwB,CAAC,IAAY,EAAE,KAAkB;IACvE,MAAM,MAAM,GAAa,EAAE,CAAC;IAE5B,+BAA+B;IAC/B,IAAI,IAAI,IAAI,IAAI,EAAE,CAAC;QACjB,OAAO,MAAM,CAAC;IAChB,CAAC;IAED,+EAA+E;IAC/E,IAAI,mBAAK,CAAC,YAAY,CAAC,IAAI,CAAC,EAAE,CAAC;QAC7B,OAAO,MAAM,CAAC;IAChB,CAAC;IAED,kBAAkB;IAClB,MAAM,CAAC,IAAI,CACT,GAAG,IAAA,8CAAyB,EAC1B;QACE,KAAK,EAAE,IAAI;QACX,SAAS,EAAE,kBAAkB;QAC7B,SAAS,EAAE,qCAA6B;QACxC,SAAS,EAAE,qCAA6B;KACzC,EACD,KAAK,CACN,CACF,CAAC;IAEF,mBAAmB;IACnB,MAAM,CAAC,IAAI,CACT,GAAG,IAAA,yCAAoB,EACrB,IAAI,EACJ,kBAAkB,EAClB,kCAA0B,EAC1B,2BAA2B,IAAI,+EAA+E,EAC9G,KAAK,CACN,CACF,CAAC;IAEF,OAAO,MAAM,CAAC;AAChB,CAAC;AAED;;;;;;;;;;GAUG;AACH,SAAgB,kBAAkB,CAAC,IAAY,EAAE,KAAkB;IACjE,MAAM,MAAM,GAAa,EAAE,CAAC;IAE5B,+BAA+B;IAC/B,IAAI,IAAI,IAAI,IAAI,EAAE,CAAC;QACjB,OAAO,MAAM,CAAC;IAChB,CAAC;IAED,+EAA+E;IAC/E,IAAI,mBAAK,CAAC,YAAY,CAAC,IAAI,CAAC,EAAE,CAAC;QAC7B,OAAO,MAAM,CAAC;IAChB,CAAC;IAED,kBAAkB;IAClB,MAAM,CAAC,IAAI,CACT,GAAG,IAAA,8CAAyB,EAC1B;QACE,KAAK,EAAE,IAAI;QACX,SAAS,EAAE,YAAY;QACvB,SAAS,EAAE,8BAAsB;QACjC,SAAS,EAAE,8BAAsB;KAClC,EACD,KAAK,CACN,CACF,CAAC;IAEF,mBAAmB;IACnB,MAAM,CAAC,IAAI,CACT,GAAG,IAAA,yCAAoB,EACrB,IAAI,EACJ,YAAY,EACZ,2BAAmB,EACnB,oBAAoB,IAAI,+EAA+E,EACvG,KAAK,CACN,CACF,CAAC;IAEF,OAAO,MAAM,CAAC;AAChB,CAAC;AAED;;;;;;;GAOG;AACH,SAAgB,wBAAwB,CAAC,UAAkB,EAAE,KAAkB;IAC7E,MAAM,MAAM,GAAa,EAAE,CAAC;IAE5B,+BAA+B;IAC/B,IAAI,UAAU,IAAI,IAAI,EAAE,CAAC;QACvB,MAAM,CAAC,IAAI,CAAC,+DAA+D,CAAC,CAAC;QAC7E,OAAO,MAAM,CAAC;IAChB,CAAC;IAED,+EAA+E;IAC/E,IAAI,mBAAK,CAAC,YAAY,CAAC,UAAU,CAAC,EAAE,CAAC;QACnC,OAAO,MAAM,CAAC;IAChB,CAAC;IAED,kBAAkB;IAClB,MAAM,CAAC,IAAI,CACT,GAAG,IAAA,8CAAyB,EAC1B;QACE,KAAK,EAAE,UAAU;QACjB,SAAS,EAAE,YAAY;QACvB,SAAS,EAAE,oCAA4B;QACvC,SAAS,EAAE,oCAA4B;KACxC,EACD,KAAK,CACN,CACF,CAAC;IAEF,OAAO,MAAM,CAAC;AAChB,CAAC;AAED;;;;;;;GAOG;AACH,SAAgB,mBAAmB,CAAC,WAAmB,EAAE,KAAkB;IACzE,MAAM,MAAM,GAAa,EAAE,CAAC;IAE5B,+BAA+B;IAC/B,IAAI,WAAW,IAAI,IAAI,EAAE,CAAC;QACxB,OAAO,MAAM,CAAC;IAChB,CAAC;IAED,+EAA+E;IAC/E,IAAI,mBAAK,CAAC,YAAY,CAAC,WAAW,CAAC,EAAE,CAAC;QACpC,OAAO,MAAM,CAAC;IAChB,CAAC;IAED,kDAAkD;IAClD,MAAM,CAAC,IAAI,CACT,GAAG,IAAA,8CAAyB,EAC1B;QACE,KAAK,EAAE,WAAW;QAClB,SAAS,EAAE,aAAa;QACxB,SAAS,EAAE,CAAC;QACZ,SAAS,EAAE,8BAAsB;KAClC,EACD,KAAK,CACN,CACF,CAAC;IAEF,OAAO,MAAM,CAAC;AAChB,CAAC;AAED;;;;;;;GAOG;AACH,SAAgB,8BAA8B,CAAC,IAAY,EAAE,KAAkB;IAC7E,OAAO,IAAA,mCAAc,EAAC,wBAAgD,EAAE,IAAI,EAAE,KAAK,CAAC,CAAC;AACvF,CAAC;AAED;;;;;;;GAOG;AACH,SAAgB,wBAAwB,CAAC,IAAY,EAAE,KAAkB;IACvE,OAAO,IAAA,mCAAc,EAAC,kBAA0C,EAAE,IAAI,EAAE,KAAK,CAAC,CAAC;AACjF,CAAC;AAED;;;;;;;GAOG;AACH,SAAgB,8BAA8B,CAAC,UAAkB,EAAE,KAAkB;IACnF,OAAO,IAAA,mCAAc,EAAC,wBAAgD,EAAE,UAAU,EAAE,KAAK,CAAC,CAAC;AAC7F,CAAC;AAED;;;;;;;GAOG;AACH,SAAgB,yBAAyB,CAAC,WAAmB,EAAE,KAAkB;IAC/E,OAAO,IAAA,mCAAc,EAAC,mBAA2C,EAAE,WAAW,EAAE,KAAK,CAAC,CAAC;AACzF,CAAC;AAED;;;;;;;;;;;;GAYG;AACH,SAAgB,YAAY,CAC1B,IAA+B,EAC/B,YAAoB,EACpB,MAAmB;IAEnB,MAAM,MAAM,GAAa,EAAE,CAAC;IAE5B,+BAA+B;IAC/B,IAAI,IAAI,IAAI,IAAI,EAAE,CAAC;QACjB,OAAO,MAAM,CAAC;IAChB,CAAC;IAED,qBAAqB;IACrB,MAAM,QAAQ,GAAG,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,MAAM,CAAC;IAC1C,IAAI,QAAQ,GAAG,gBAAQ,EAAE,CAAC;QACxB,MAAM,CAAC,IAAI,CACT,iBAAiB,YAAY,2BAA2B,gBAAQ,iBAAiB,QAAQ,EAAE,CAC5F,CAAC;IACJ,CAAC;IAED,oBAAoB;IACpB,KAAK,MAAM,CAAC,GAAG,EAAE,KAAK,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,IAAI,CAAC,EAAE,CAAC;QAChD,4CAA4C;QAC5C,IAAI,CAAC,mBAAK,CAAC,YAAY,CAAC,GAAG,CAAC,EAAE,CAAC;YAC7B,sBAAsB;YACtB,IAAI,GAAG,CAAC,MAAM,GAAG,0BAAkB,IAAI,GAAG,CAAC,MAAM,GAAG,0BAAkB,EAAE,CAAC;gBACvE,MAAM,CAAC,IAAI,CACT,iBAAiB,YAAY,oCAAoC,0BAAkB,QAAQ,0BAAkB,eAAe;oBAC1H,SAAS,GAAG,gBAAgB,GAAG,CAAC,MAAM,EAAE,CAC3C,CAAC;YACJ,CAAC;YAED,uBAAuB;YACvB,IAAI,CAAC,uBAAe,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC;gBAC/B,MAAM,CAAC,IAAI,CACT,iBAAiB,YAAY,yCAAyC;oBACpE,SAAS,GAAG,6CAA6C,CAC5D,CAAC;YACJ,CAAC;QACH,CAAC;QAED,8CAA8C;QAC9C,IAAI,CAAC,mBAAK,CAAC,YAAY,CAAC,KAAK,CAAC,EAAE,CAAC;YAC/B,wBAAwB;YACxB,IAAI,KAAK,CAAC,MAAM,GAAG,4BAAoB,EAAE,CAAC;gBACxC,MAAM,CAAC,IAAI,CACT,iBAAiB,YAAY,oCAAoC,4BAAoB,eAAe;oBAClG,SAAS,GAAG,uBAAuB,KAAK,CAAC,MAAM,EAAE,CACpD,CAAC;YACJ,CAAC;YAED,yBAAyB;YACzB,IAAI,CAAC,yBAAiB,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC;gBACnC,MAAM,CAAC,IAAI,CACT,iBAAiB,YAAY,2CAA2C;oBACtE,SAAS,GAAG,cAAc,KAAK,6CAA6C,CAC/E,CAAC;YACJ,CAAC;QACH,CAAC;IACH,CAAC;IAED,OAAO,MAAM,CAAC;AAChB,CAAC;AAED;;;;;;;;GAQG;AACH,SAAgB,kBAAkB,CAChC,IAA+B,EAC/B,YAAoB,EACpB,KAAkB;IAElB,OAAO,IAAA,mCAAc,EACnB,CAAC,CAA4B,EAAE,CAAc,EAAE,EAAE,CAAC,YAAY,CAAC,CAAC,EAAE,YAAY,EAAE,CAAC,CAAC,EAClF,IAAI,EACJ,KAAK,CACN,CAAC;AACJ,CAAC","sourcesContent":["import { Token } from 'aws-cdk-lib';\nimport type { IConstruct } from 'constructs';\nimport {\n  validateStringFieldLength,\n  validateFieldPattern,\n  throwIfInvalid,\n  type ValidationFn,\n} from '../memory/validation-helpers';\n\n/**\n * Validation constants for PolicyEngine\n */\nexport const POLICY_ENGINE_NAME_MIN_LENGTH = 1;\nexport const POLICY_ENGINE_NAME_MAX_LENGTH = 48;\nexport const POLICY_ENGINE_NAME_PATTERN = /^[A-Za-z][A-Za-z0-9_]*$/;\n\n/**\n * Validation constants for Policy\n */\nexport const POLICY_NAME_MIN_LENGTH = 1;\nexport const POLICY_NAME_MAX_LENGTH = 48;\nexport const POLICY_NAME_PATTERN = /^[A-Za-z][A-Za-z0-9_]*$/;\n\n/**\n * Validation constants for Cedar policy definitions\n */\nexport const POLICY_DEFINITION_MIN_LENGTH = 35;\nexport const POLICY_DEFINITION_MAX_LENGTH = 153600;\n\n/**\n * Validation constants for descriptions\n */\nexport const DESCRIPTION_MAX_LENGTH = 4096;\n\n/**\n * Validation constants for tags\n */\nexport const MAX_TAGS = 50;\nexport const TAG_KEY_MIN_LENGTH = 1;\nexport const TAG_KEY_MAX_LENGTH = 128;\nexport const TAG_VALUE_MAX_LENGTH = 256;\nexport const TAG_KEY_PATTERN = /^[a-zA-Z0-9\\s._:/=+@-]+$/;\nexport const TAG_VALUE_PATTERN = /^[a-zA-Z0-9\\s._:/=+@-]*$/;\n\n/**\n * Validates a policy engine name.\n * Names must:\n * - Start with a letter (a-z, A-Z)\n * - Contain only letters, numbers, and underscores\n * - Be between 1 and 48 characters\n *\n * @param name - The policy engine name to validate\n * @param scope - The construct scope for error reporting (optional)\n * @returns Array of validation error messages, empty if valid\n */\nexport function validatePolicyEngineName(name: string, scope?: IConstruct): string[] {\n  const errors: string[] = [];\n\n  // Handle null/undefined values\n  if (name == null) {\n    return errors;\n  }\n\n  // Skip validation for unresolved tokens (e.g. Lazy.string(), cross-stack refs)\n  if (Token.isUnresolved(name)) {\n    return errors;\n  }\n\n  // Validate length\n  errors.push(\n    ...validateStringFieldLength(\n      {\n        value: name,\n        fieldName: 'policyEngineName',\n        minLength: POLICY_ENGINE_NAME_MIN_LENGTH,\n        maxLength: POLICY_ENGINE_NAME_MAX_LENGTH,\n      },\n      scope,\n    ),\n  );\n\n  // Validate pattern\n  errors.push(\n    ...validateFieldPattern(\n      name,\n      'policyEngineName',\n      POLICY_ENGINE_NAME_PATTERN,\n      `The policy engine name \"${name}\" must start with a letter and contain only letters, numbers, and underscores`,\n      scope,\n    ),\n  );\n\n  return errors;\n}\n\n/**\n * Validates a policy name.\n * Names must:\n * - Start with a letter (a-z, A-Z)\n * - Contain only letters, numbers, and underscores\n * - Be between 1 and 48 characters\n *\n * @param name - The policy name to validate\n * @param scope - The construct scope for error reporting (optional)\n * @returns Array of validation error messages, empty if valid\n */\nexport function validatePolicyName(name: string, scope?: IConstruct): string[] {\n  const errors: string[] = [];\n\n  // Handle null/undefined values\n  if (name == null) {\n    return errors;\n  }\n\n  // Skip validation for unresolved tokens (e.g. Lazy.string(), cross-stack refs)\n  if (Token.isUnresolved(name)) {\n    return errors;\n  }\n\n  // Validate length\n  errors.push(\n    ...validateStringFieldLength(\n      {\n        value: name,\n        fieldName: 'policyName',\n        minLength: POLICY_NAME_MIN_LENGTH,\n        maxLength: POLICY_NAME_MAX_LENGTH,\n      },\n      scope,\n    ),\n  );\n\n  // Validate pattern\n  errors.push(\n    ...validateFieldPattern(\n      name,\n      'policyName',\n      POLICY_NAME_PATTERN,\n      `The policy name \"${name}\" must start with a letter and contain only letters, numbers, and underscores`,\n      scope,\n    ),\n  );\n\n  return errors;\n}\n\n/**\n * Validates a Cedar policy definition string.\n * Definitions must be between 35 and 153,600 characters.\n *\n * @param definition - The Cedar policy definition to validate\n * @param scope - The construct scope for error reporting (optional)\n * @returns Array of validation error messages, empty if valid\n */\nexport function validatePolicyDefinition(definition: string, scope?: IConstruct): string[] {\n  const errors: string[] = [];\n\n  // Handle null/undefined values\n  if (definition == null) {\n    errors.push('Policy definition is required and cannot be null or undefined');\n    return errors;\n  }\n\n  // Skip validation for unresolved tokens (e.g. Lazy.string(), cross-stack refs)\n  if (Token.isUnresolved(definition)) {\n    return errors;\n  }\n\n  // Validate length\n  errors.push(\n    ...validateStringFieldLength(\n      {\n        value: definition,\n        fieldName: 'definition',\n        minLength: POLICY_DEFINITION_MIN_LENGTH,\n        maxLength: POLICY_DEFINITION_MAX_LENGTH,\n      },\n      scope,\n    ),\n  );\n\n  return errors;\n}\n\n/**\n * Validates a description string.\n * Descriptions must not exceed 4,096 characters.\n *\n * @param description - The description to validate\n * @param scope - The construct scope for error reporting (optional)\n * @returns Array of validation error messages, empty if valid\n */\nexport function validateDescription(description: string, scope?: IConstruct): string[] {\n  const errors: string[] = [];\n\n  // Handle null/undefined values\n  if (description == null) {\n    return errors;\n  }\n\n  // Skip validation for unresolved tokens (e.g. Lazy.string(), cross-stack refs)\n  if (Token.isUnresolved(description)) {\n    return errors;\n  }\n\n  // Validate length (no minimum length requirement)\n  errors.push(\n    ...validateStringFieldLength(\n      {\n        value: description,\n        fieldName: 'description',\n        minLength: 0,\n        maxLength: DESCRIPTION_MAX_LENGTH,\n      },\n      scope,\n    ),\n  );\n\n  return errors;\n}\n\n/**\n * Validates a policy engine name and throws if invalid.\n *\n * @param name - The policy engine name to validate\n * @param scope - The construct scope for error reporting (optional)\n * @returns The validated name\n * @throws ValidationError if validation fails\n */\nexport function throwIfInvalidPolicyEngineName(name: string, scope?: IConstruct): string {\n  return throwIfInvalid(validatePolicyEngineName as ValidationFn<string>, name, scope);\n}\n\n/**\n * Validates a policy name and throws if invalid.\n *\n * @param name - The policy name to validate\n * @param scope - The construct scope for error reporting (optional)\n * @returns The validated name\n * @throws ValidationError if validation fails\n */\nexport function throwIfInvalidPolicyName(name: string, scope?: IConstruct): string {\n  return throwIfInvalid(validatePolicyName as ValidationFn<string>, name, scope);\n}\n\n/**\n * Validates a policy definition and throws if invalid.\n *\n * @param definition - The Cedar policy definition to validate\n * @param scope - The construct scope for error reporting (optional)\n * @returns The validated definition\n * @throws ValidationError if validation fails\n */\nexport function throwIfInvalidPolicyDefinition(definition: string, scope?: IConstruct): string {\n  return throwIfInvalid(validatePolicyDefinition as ValidationFn<string>, definition, scope);\n}\n\n/**\n * Validates a description and throws if invalid.\n *\n * @param description - The description to validate\n * @param scope - The construct scope for error reporting (optional)\n * @returns The validated description\n * @throws ValidationError if validation fails\n */\nexport function throwIfInvalidDescription(description: string, scope?: IConstruct): string {\n  return throwIfInvalid(validateDescription as ValidationFn<string>, description, scope);\n}\n\n/**\n * Validates tags for a PolicyEngine.\n * Tags must:\n * - Not exceed 50 tags\n * - Have keys between 1 and 128 characters\n * - Have values between 0 and 256 characters\n * - Match allowed character patterns\n *\n * @param tags - The tags object to validate\n * @param resourceName - The name of the resource being tagged (for error messages)\n * @param scope - The construct scope for error reporting (optional)\n * @returns Array of validation error messages, empty if valid\n */\nexport function validateTags(\n  tags: { [key: string]: string },\n  resourceName: string,\n  _scope?: IConstruct,\n): string[] {\n  const errors: string[] = [];\n\n  // Handle null/undefined values\n  if (tags == null) {\n    return errors;\n  }\n\n  // Validate tag count\n  const tagCount = Object.keys(tags).length;\n  if (tagCount > MAX_TAGS) {\n    errors.push(\n      `PolicyEngine '${resourceName}' cannot have more than ${MAX_TAGS} tags. Found: ${tagCount}`,\n    );\n  }\n\n  // Validate each tag\n  for (const [key, value] of Object.entries(tags)) {\n    // Skip validation for unresolved token keys\n    if (!Token.isUnresolved(key)) {\n      // Validate key length\n      if (key.length < TAG_KEY_MIN_LENGTH || key.length > TAG_KEY_MAX_LENGTH) {\n        errors.push(\n          `PolicyEngine '${resourceName}' tag key length must be between ${TAG_KEY_MIN_LENGTH} and ${TAG_KEY_MAX_LENGTH} characters. ` +\n            `Key: \"${key}\" has length ${key.length}`,\n        );\n      }\n\n      // Validate key pattern\n      if (!TAG_KEY_PATTERN.test(key)) {\n        errors.push(\n          `PolicyEngine '${resourceName}' tag key contains invalid characters. ` +\n            `Key: \"${key}\". Valid characters: a-zA-Z0-9 and ._:/=+@-`,\n        );\n      }\n    }\n\n    // Skip validation for unresolved token values\n    if (!Token.isUnresolved(value)) {\n      // Validate value length\n      if (value.length > TAG_VALUE_MAX_LENGTH) {\n        errors.push(\n          `PolicyEngine '${resourceName}' tag value length cannot exceed ${TAG_VALUE_MAX_LENGTH} characters. ` +\n            `Key: \"${key}\", value has length ${value.length}`,\n        );\n      }\n\n      // Validate value pattern\n      if (!TAG_VALUE_PATTERN.test(value)) {\n        errors.push(\n          `PolicyEngine '${resourceName}' tag value contains invalid characters. ` +\n            `Key: \"${key}\", Value: \"${value}\". Valid characters: a-zA-Z0-9 and ._:/=+@-`,\n        );\n      }\n    }\n  }\n\n  return errors;\n}\n\n/**\n * Validates tags and throws if invalid.\n *\n * @param tags - The tags object to validate\n * @param resourceName - The name of the resource being tagged (for error messages)\n * @param scope - The construct scope for error reporting (optional)\n * @returns The validated tags\n * @throws ValidationError if validation fails\n */\nexport function throwIfInvalidTags(\n  tags: { [key: string]: string },\n  resourceName: string,\n  scope?: IConstruct,\n): { [key: string]: string } {\n  return throwIfInvalid(\n    (t: { [key: string]: string }, s?: IConstruct) => validateTags(t, resourceName, s),\n    tags,\n    scope,\n  );\n}\n"]}

package/lib/runtime/inbound-auth/custom-claim.js

@@ -29,7 +29,7 @@ class RuntimeCustomClaim {
     valueType;
     operator;
     value;
-    static [JSII_RTTI_SYMBOL_1] = { fqn: "@aws-cdk/aws-bedrock-agentcore-alpha.RuntimeCustomClaim", version: "2.250.0-alpha.0" };
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "@aws-cdk/aws-bedrock-agentcore-alpha.RuntimeCustomClaim", version: "2.252.0-alpha.0" };
     /**
      * Create a custom claim with a string value.
      * String claims must use the EQUALS operator.

package/lib/runtime/inbound-auth/runtime-authorizer-configuration.js

@@ -22,7 +22,7 @@ const helpers_internal_1 = require("aws-cdk-lib/core/lib/helpers-internal");
  * Provides static factory methods to create different authentication types.
  */
 class RuntimeAuthorizerConfiguration {
-    static [JSII_RTTI_SYMBOL_1] = { fqn: "@aws-cdk/aws-bedrock-agentcore-alpha.RuntimeAuthorizerConfiguration", version: "2.250.0-alpha.0" };
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "@aws-cdk/aws-bedrock-agentcore-alpha.RuntimeAuthorizerConfiguration", version: "2.252.0-alpha.0" };
     /**
      * Use IAM authentication (default).
      * Requires AWS credentials to sign requests using SigV4.

package/lib/runtime/observability.d.ts

@@ -0,0 +1,105 @@
+import type { IDeliveryStream } from 'aws-cdk-lib/aws-kinesisfirehose';
+import * as logs from 'aws-cdk-lib/aws-logs';
+import type * as s3 from 'aws-cdk-lib/aws-s3';
+import { Construct } from 'constructs';
+/**
+ * Log types for AgentCore Runtime observability
+ */
+export declare class LogType {
+    /**
+     * The log type value
+     */
+    readonly value: string;
+    /**
+     * Application logs for agent runtime invocations
+     */
+    static readonly APPLICATION_LOGS: LogType;
+    /**
+     * Usage logs for session-level resource consumption
+     */
+    static readonly USAGE_LOGS: LogType;
+    /**
+     * A custom log type value
+     *
+     * @param value The log type value
+     */
+    static of(value: string): LogType;
+    private constructor();
+}
+/**
+ * Configuration for logging with log type and destination
+ */
+export interface LoggingConfig {
+    /**
+     * The type of logs to deliver
+     */
+    readonly logType: LogType;
+    /**
+     * The destination for logs
+     */
+    readonly destination: LoggingDestination;
+}
+/**
+ * Configuration returned by LoggingDestination.bind()
+ * @internal
+ */
+interface LoggingDestinationBindConfig {
+    /**
+     * The delivery destination construct
+     */
+    readonly deliveryDestination: logs.CfnDeliveryDestination;
+}
+/**
+ * Represents a logging destination for AgentCore Runtime
+ *
+ * Use the static factory methods to create instances:
+ * - `LoggingDestination.cloudWatchLogs(logGroup)` - Send logs to CloudWatch Logs
+ * - `LoggingDestination.s3(bucket)` - Send logs to S3
+ * - `LoggingDestination.firehose(stream)` - Send logs to Kinesis Data Firehose
+ */
+export declare abstract class LoggingDestination {
+    /**
+     * Create a logging destination that sends logs to a CloudWatch Log Group
+     *
+     * @param logGroup The CloudWatch Log Group to send logs to
+     */
+    static cloudWatchLogs(logGroup: logs.ILogGroup): LoggingDestination;
+    /**
+     * Create a logging destination that sends logs to an S3 bucket
+     *
+     * @param bucket The S3 bucket to send logs to
+     */
+    static s3(bucket: s3.IBucket): LoggingDestination;
+    /**
+     * Create a logging destination that sends logs to a Kinesis Data Firehose delivery stream
+     *
+     * @param stream The Firehose delivery stream to send logs to
+     */
+    static firehose(stream: IDeliveryStream): LoggingDestination;
+    /**
+     * Bind this destination to a scope and create the delivery destination resource
+     *
+     * @param scope The construct scope
+     * @param id The construct id
+     * @internal
+     */
+    abstract _bind(scope: Construct, id: string): LoggingDestinationBindConfig;
+}
+/**
+ * Configure X-Ray tracing delivery for a runtime
+ *
+ * @param scope The construct scope
+ * @param sourceArn The ARN of the source resource (runtime)
+ * @internal
+ */
+export declare function configureTracingDelivery(scope: Construct, sourceArn: string): logs.CfnDelivery;
+/**
+ * Configure logging delivery for a runtime
+ *
+ * @param scope The construct scope
+ * @param sourceArn The ARN of the source resource (runtime)
+ * @param loggingConfigs Array of logging configurations
+ * @internal
+ */
+export declare function configureLoggingDelivery(scope: Construct, sourceArn: string, loggingConfigs: LoggingConfig[]): logs.CfnDelivery[];
+export {};