@aligent/cdk-aspects 0.5.2 → 0.5.5

package/CHANGELOG.md

@@ -1,5 +1,42 @@
 # @aligent/cdk-aspects
 
+## 0.5.5
+
+### Patch Changes
+
+- [#1639](https://github.com/aligent/cdk-constructs/pull/1639) [`060f291`](https://github.com/aligent/cdk-constructs/commit/060f29103f3fd2146bd2d88de54d0e2009f55910) Thanks [@dependabot](https://github.com/apps/dependabot)! - chore(deps-dev): bump ts-jest from 29.4.6 to 29.4.9 in the testing-tools group across 1 directory
+
+- [#1642](https://github.com/aligent/cdk-constructs/pull/1642) [`d760efe`](https://github.com/aligent/cdk-constructs/commit/d760efe3baec8e33df1b49415de815e2bfd128e5) Thanks [@dependabot](https://github.com/apps/dependabot)! - chore(deps): bump the aws group across 1 directory with 11 updates
+
+- [#1658](https://github.com/aligent/cdk-constructs/pull/1658) [`9da935e`](https://github.com/aligent/cdk-constructs/commit/9da935eaf79dd4fa6a07fc1d183fbe04c5c74501) Thanks [@dependabot](https://github.com/apps/dependabot)! - chore(deps): bump the npm_and_yarn group across 1 directory with 2 updates
+
+## 0.5.4
+
+### Patch Changes
+
+- [#1660](https://github.com/aligent/cdk-constructs/pull/1660) [`d2fb7aa`](https://github.com/aligent/cdk-constructs/commit/d2fb7aa1c03fcf4257d8f5883bf5765510885486) Thanks [@toddhainsworth](https://github.com/toddhainsworth)! - Fixed `StepFunctionsDefaultsAspect` missing IAM grants for CloudWatch Logs delivery. The aspect was setting `loggingConfiguration` directly on the L1 `CfnStateMachine`, bypassing CDK's IAM grant mechanism. The state machine role now receives the required `logs:*` permissions, preventing the `"IAM Role is not authorized to access the Log Destination"` CloudFormation error on deployment.
+
+## 0.5.3
+
+### Patch Changes
+
+- [#1661](https://github.com/aligent/cdk-constructs/pull/1661) [`25cf7c9`](https://github.com/aligent/cdk-constructs/commit/25cf7c9fc6427a9c5a15f01928ee2121c03a3ec7) Thanks [@toddhainsworth](https://github.com/toddhainsworth)! - Fixed `ResourcePrefixAspect` failing synthesis when a prefixed resource name exceeds the AWS maximum length. The aspect now truncates the name and appends an 8-character SHA-256 hash to maintain uniqueness, and emits a `cdk synth` warning identifying the original and truncated name. This prevents L3 constructs (e.g. `BucketDeployment`) from generating child resources that the user has no control over causing failed deployments.
+
+- [#1654](https://github.com/aligent/cdk-constructs/pull/1654) [`99d96c9`](https://github.com/aligent/cdk-constructs/commit/99d96c95b237b9b1d9e341957d621025e0c3bd6a) Thanks [@kai-nguyen-aligent](https://github.com/kai-nguyen-aligent)! - ### `@aligent/cdk-nodejs-function-from-entry` (minor)
+  - **Changed base class from `Function` to `NodejsFunction`** — the construct now extends `NodejsFunction` (and accepts `NodejsFunctionProps`) instead of the generic `Function`, enabling Node.js-specific bundling options. The parent `entry` prop is omitted to avoid conflicts with the custom typed `entry`.
+  - **Added `NoInfer` to the `entry` generic parameter** — prevents TypeScript from incorrectly inferring `TPrefix` from the `entry` value; the prefix is now inferred solely from `sourcePrefix`.
+  - **Made `runtime` optional** — consumers no longer need to explicitly pass a runtime.
+  - **Improved path traversal validation** — replaced the simple relative-path check with a `findServiceRoot` helper that walks up to a configurable `rootParentDir` ancestor, giving clearer error messages on invalid paths.
+  - **Added `rootParentDir` prop** (default: `'services'`) to control the allowed root for asset resolution.
+
+  ### `@aligent/cdk-step-function-from-file` (minor)
+  - **Added `NoInfer` to the `filepath` generic parameter** — prevents unintended type inference from the `filepath` value.
+  - **Improved path traversal validation** — uses the same `findServiceRoot` approach as the Lambda construct for consistent, configurable path safety checks.
+  - **Added `rootParentDir` prop** (default: `'services'`) to control the allowed root for asset resolution.
+
+  ### `@aligent/cdk-aspects` (patch)
+  - **Updated `NodeJsFunctionDefaultsAspect` JSDoc** — clarified that the configured runtime is always applied to ensure consistency, while other defaults (tracing, memory, timeout, source maps) are only applied when not already set.
+
 ## 0.5.2
 
 ### Patch Changes

package/README.md

@@ -105,6 +105,64 @@ const stack = new Stack(app, "MyStack");
 Aspects.of(stack).add(new MicroserviceChecks());
 ```
 
+## Resource Prefix
+
+Automatically prefixes physical resource names across supported AWS resource types. Ensures all resources in a stack share a consistent naming scheme (e.g. `myapp-prod-orders-function`), which is especially useful for identifying resources by environment or service in the AWS console.
+
+### Features
+
+- Prefixes names for Lambda functions, S3 buckets, DynamoDB tables, SQS queues, SNS topics, IAM roles, SSM parameters, Step Functions, EventBridge rules, and more
+- Handles resource-specific naming rules: S3 names are lowercased, FIFO queues/topics preserve the `.fifo` suffix, SSM parameters use path-style prefixes (`/prefix/name`)
+- **Automatic truncation**: if a prefixed name would exceed AWS's maximum length for that resource type, the aspect truncates the name and appends an 8-character SHA-256 hash to maintain uniqueness. A CDK warning is emitted for each truncated resource. This prevents L3 constructs (e.g. `BucketDeployment`) from generating child resources that cause synthesis failures.
+- Idempotent: already-prefixed resources are skipped
+- Supports an exclusion list to skip specific resource types
+
+### Usage
+
+```typescript
+import { Aspects } from "aws-cdk-lib";
+import { ResourcePrefixAspect } from "@aligent/cdk-aspects";
+
+const stage = new ApplicationStage(app, "prod");
+Aspects.of(stage).add(new ResourcePrefixAspect({ prefix: "myapp-prod" }));
+```
+
+Excluding specific resource types:
+
+```typescript
+Aspects.of(stage).add(
+  new ResourcePrefixAspect({
+    prefix: "myapp-prod",
+    exclude: ["AWS::IAM::Role"],
+  })
+);
+```
+
+### Truncation behaviour
+
+When a prefixed name exceeds the AWS maximum for its resource type, the aspect:
+
+1. Hashes the full (pre-truncation) name with SHA-256 and takes the first 8 hex characters
+2. Truncates the name to fit within the limit, preserving any required suffix (e.g. `.fifo`)
+3. Emits a `cdk synth` warning identifying the original and truncated name
+
+This applies to all overflows, including explicitly user-set names. The warning tells you which resources were affected so you can shorten the base name or prefix if desired.
+
+Example warning:
+```
+[ResourcePrefixAspect] "myapp-prod-VeryLongGeneratedFunctionName" (72 chars) exceeds the maximum allowed length of 64. Name has been truncated to "myapp-prod-VeryLongGenerate-a3f9c2d1". Shorten the resource base name or your prefix ("myapp-prod") to avoid truncation.
+```
+
+### Critical notes
+
+- **Apply to each `Stage`, not the `App`**: CDK Stage constructs create synthesis boundaries. Apply the aspect to each Stage individually.
+- **Aspect priority with versioning**: when combining with `LambdaAndStepFunctionVersioningAspect`, apply this aspect first using CDK's priority system (lower number = runs first):
+
+```typescript
+Aspects.of(stage).add(new ResourcePrefixAspect({ prefix: "myapp" }), { priority: 100 });
+Aspects.of(stage).add(new LambdaAndStepFunctionVersioningAspect(), { priority: 200 });
+```
+
 ## Version Functions
 
 An aspect that automatically adds versioning and aliases to Lambda functions and Step Functions.

package/lib/defaults/nodejs-function.d.ts

@@ -40,10 +40,12 @@ export declare class NodeJsFunctionDefaultsAspect implements IAspect {
      */
     constructor(config: Config);
     /**
-     * Visits a construct and applies runtime and tracing settings if it's a NodejsFunction
+     * Visits a construct and applies defaults if it's a Node.js Lambda function.
      *
-     * Applies configuration-specific runtime, tracing, and environment settings to Node.js
-     * Lambda functions that don't already have these properties explicitly set.
+     * The configured runtime is **always** applied to
+     * ensure consistency across the stack — even if the function already
+     * specifies a Node.js runtime. Tracing, memory, timeout, and source map
+     * settings are only applied when not already explicitly set.
      *
      * @param node - The construct to potentially modify
      */

package/lib/defaults/nodejs-function.js

@@ -43,10 +43,12 @@ class NodeJsFunctionDefaultsAspect {
         };
     }
     /**
-     * Visits a construct and applies runtime and tracing settings if it's a NodejsFunction
+     * Visits a construct and applies defaults if it's a Node.js Lambda function.
      *
-     * Applies configuration-specific runtime, tracing, and environment settings to Node.js
-     * Lambda functions that don't already have these properties explicitly set.
+     * The configured runtime is **always** applied to
+     * ensure consistency across the stack — even if the function already
+     * specifies a Node.js runtime. Tracing, memory, timeout, and source map
+     * settings are only applied when not already explicitly set.
      *
      * @param node - The construct to potentially modify
      */
@@ -72,4 +74,4 @@ class NodeJsFunctionDefaultsAspect {
     }
 }
 exports.NodeJsFunctionDefaultsAspect = NodeJsFunctionDefaultsAspect;
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/lib/defaults/step-functions.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.StepFunctionsDefaultsAspect = void 0;
+const aws_iam_1 = require("aws-cdk-lib/aws-iam");
 const aws_logs_1 = require("aws-cdk-lib/aws-logs");
 const aws_stepfunctions_1 = require("aws-cdk-lib/aws-stepfunctions");
 /**
@@ -48,27 +49,46 @@ class StepFunctionsDefaultsAspect {
                 // For EXPRESS state machines, configure logging if not already set
                 if (cfnStateMachine.stateMachineType === aws_stepfunctions_1.StateMachineType.EXPRESS &&
                     cfnStateMachine.loggingConfiguration === undefined) {
-                    // Create a log group for the state machine
                     const logGroup = new aws_logs_1.LogGroup(node, "LogGroup", {
                         logGroupName: `/aws/vendedlogs/states/${node.node.id}`,
                     });
-                    // Get the underlying CFN log group to access its ARN
-                    const cfnLogGroup = logGroup.node.defaultChild;
                     cfnStateMachine.loggingConfiguration = {
                         destinations: [
                             {
                                 cloudWatchLogsLogGroup: {
-                                    logGroupArn: cfnLogGroup.attrArn,
+                                    logGroupArn: logGroup.logGroupArn,
                                 },
                             },
                         ],
                         level: aws_stepfunctions_1.LogLevel.ALL,
                         includeExecutionData: true,
                     };
+                    // Grant the state machine role the permissions required to deliver logs.
+                    // Mirrors what CDK's StateMachine.buildLoggingConfiguration() does internally.
+                    //
+                    // resources: ["*"] is intentional — all eight actions are vended-log-delivery
+                    // control-plane APIs that operate at the account level and do not support
+                    // resource-level scoping against a specific log group ARN.
+                    // See: https://docs.aws.amazon.com/service-authorization/latest/reference/list_amazoncloudwatchlogs.html
+                    //      https://docs.aws.amazon.com/step-functions/latest/dg/cw-logs.html
+                    node.addToRolePolicy(new aws_iam_1.PolicyStatement({
+                        effect: aws_iam_1.Effect.ALLOW,
+                        actions: [
+                            "logs:CreateLogDelivery",
+                            "logs:GetLogDelivery",
+                            "logs:UpdateLogDelivery",
+                            "logs:DeleteLogDelivery",
+                            "logs:ListLogDeliveries",
+                            "logs:PutResourcePolicy",
+                            "logs:DescribeResourcePolicies",
+                            "logs:DescribeLogGroups",
+                        ],
+                        resources: ["*"],
+                    }));
                 }
             }
         }
     }
 }
 exports.StepFunctionsDefaultsAspect = StepFunctionsDefaultsAspect;
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3RlcC1mdW5jdGlvbnMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyJzdGVwLWZ1bmN0aW9ucy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7QUFDQSxpREFBOEQ7QUFDOUQsbURBQWdEO0FBQ2hELHFFQUt1QztBQUd2Qzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7O0dBcUJHO0FBQ0gsTUFBYSwyQkFBMkI7SUFDdEM7Ozs7Ozs7O09BUUc7SUFDSCxLQUFLLENBQUMsSUFBZ0I7UUFDcEIsSUFBSSxJQUFJLFlBQVksZ0NBQVksRUFBRSxDQUFDO1lBQ2pDLE1BQU0sZUFBZSxHQUFHLElBQUksQ0FBQyxJQUFJLENBQUMsWUFBK0IsQ0FBQztZQUVsRSxJQUFJLGVBQWUsRUFBRSxDQUFDO2dCQUNwQixtQ0FBbUM7Z0JBQ25DLElBQUksZUFBZSxDQUFDLG9CQUFvQixLQUFLLFNBQVMsRUFBRSxDQUFDO29CQUN2RCxlQUFlLENBQUMsb0JBQW9CLEdBQUc7d0JBQ3JDLE9BQU8sRUFBRSxJQUFJO3FCQUNkLENBQUM7Z0JBQ0osQ0FBQztnQkFFRCxtRUFBbUU7Z0JBQ25FLElBQ0UsZUFBZSxDQUFDLGdCQUFnQixLQUFLLG9DQUFnQixDQUFDLE9BQU87b0JBQzdELGVBQWUsQ0FBQyxvQkFBb0IsS0FBSyxTQUFTLEVBQ2xELENBQUM7b0JBQ0QsTUFBTSxRQUFRLEdBQUcsSUFBSSxtQkFBUSxDQUFDLElBQUksRUFBRSxVQUFVLEVBQUU7d0JBQzlDLFlBQVksRUFBRSwwQkFBMEIsSUFBSSxDQUFDLElBQUksQ0FBQyxFQUFFLEVBQUU7cUJBQ3ZELENBQUMsQ0FBQztvQkFFSCxlQUFlLENBQUMsb0JBQW9CLEdBQUc7d0JBQ3JDLFlBQVksRUFBRTs0QkFDWjtnQ0FDRSxzQkFBc0IsRUFBRTtvQ0FDdEIsV0FBVyxFQUFFLFFBQVEsQ0FBQyxXQUFXO2lDQUNsQzs2QkFDRjt5QkFDRjt3QkFDRCxLQUFLLEVBQUUsNEJBQVEsQ0FBQyxHQUFHO3dCQUNuQixvQkFBb0IsRUFBRSxJQUFJO3FCQUMzQixDQUFDO29CQUVGLHlFQUF5RTtvQkFDekUsK0VBQStFO29CQUMvRSxFQUFFO29CQUNGLDhFQUE4RTtvQkFDOUUsMEVBQTBFO29CQUMxRSwyREFBMkQ7b0JBQzNELHlHQUF5RztvQkFDekcseUVBQXlFO29CQUN6RSxJQUFJLENBQUMsZUFBZSxDQUNsQixJQUFJLHlCQUFlLENBQUM7d0JBQ2xCLE1BQU0sRUFBRSxnQkFBTSxDQUFDLEtBQUs7d0JBQ3BCLE9BQU8sRUFBRTs0QkFDUCx3QkFBd0I7NEJBQ3hCLHFCQUFxQjs0QkFDckIsd0JBQXdCOzRCQUN4Qix3QkFBd0I7NEJBQ3hCLHdCQUF3Qjs0QkFDeEIsd0JBQXdCOzRCQUN4QiwrQkFBK0I7NEJBQy9CLHdCQUF3Qjt5QkFDekI7d0JBQ0QsU0FBUyxFQUFFLENBQUMsR0FBRyxDQUFDO3FCQUNqQixDQUFDLENBQ0gsQ0FBQztnQkFDSixDQUFDO1lBQ0gsQ0FBQztRQUNILENBQUM7SUFDSCxDQUFDO0NBQ0Y7QUF2RUQsa0VBdUVDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgdHlwZSBJQXNwZWN0IH0gZnJvbSBcImF3cy1jZGstbGliXCI7XG5pbXBvcnQgeyBFZmZlY3QsIFBvbGljeVN0YXRlbWVudCB9IGZyb20gXCJhd3MtY2RrLWxpYi9hd3MtaWFtXCI7XG5pbXBvcnQgeyBMb2dHcm91cCB9IGZyb20gXCJhd3MtY2RrLWxpYi9hd3MtbG9nc1wiO1xuaW1wb3J0IHtcbiAgQ2ZuU3RhdGVNYWNoaW5lLFxuICBMb2dMZXZlbCxcbiAgU3RhdGVNYWNoaW5lLFxuICBTdGF0ZU1hY2hpbmVUeXBlLFxufSBmcm9tIFwiYXdzLWNkay1saWIvYXdzLXN0ZXBmdW5jdGlvbnNcIjtcbmltcG9ydCB7IElDb25zdHJ1Y3QgfSBmcm9tIFwiY29uc3RydWN0c1wiO1xuXG4vKipcbiAqIEFzcGVjdCB0aGF0IGF1dG9tYXRpY2FsbHkgYXBwbGllcyB0cmFjaW5nIGFuZCBsb2dnaW5nIHNldHRpbmdzIHRvIFN0ZXAgRnVuY3Rpb25zXG4gKlxuICogVmlzaXRzIGFsbCBjb25zdHJ1Y3RzIGluIHRoZSBzY29wZSBhbmQgYXV0b21hdGljYWxseSBhcHBsaWVzIFgtUmF5IHRyYWNpbmcgdG8gYWxsXG4gKiBzdGF0ZSBtYWNoaW5lcy4gRm9yIEVYUFJFU1Mgc3RhdGUgbWFjaGluZXMsIGF1dG9tYXRpY2FsbHkgY3JlYXRlcyBsb2cgZ3JvdXBzIGFuZFxuICogY29uZmlndXJlcyBjb21wcmVoZW5zaXZlIGxvZ2dpbmcgZm9yIGVuaGFuY2VkIG9ic2VydmFiaWxpdHkuXG4gKlxuICogQGV4YW1wbGVcbiAqIGBgYHR5cGVzY3JpcHRcbiAqIC8vIEFwcGx5IGNvbmZpZ3VyYXRpb24tc3BlY2lmaWMgZGVmYXVsdHMgdG8gYWxsIFN0ZXAgRnVuY3Rpb25zXG4gKiBBc3BlY3RzLm9mKGFwcCkuYWRkKG5ldyBTdGVwRnVuY3Rpb25EZWZhdWx0c0FzcGVjdCgpKTtcbiAqXG4gKiAvLyBTdGVwIEZ1bmN0aW9ucyBhdXRvbWF0aWNhbGx5IGluaGVyaXQgZGVmYXVsdHNcbiAqIG5ldyBTdGF0ZU1hY2hpbmUoc3RhY2ssICdNeVdvcmtmbG93Jywge1xuICogICBzdGF0ZU1hY2hpbmVUeXBlOiBTdGF0ZU1hY2hpbmVUeXBlLkVYUFJFU1MsXG4gKiAgIGRlZmluaXRpb25Cb2R5OiBEZWZpbml0aW9uQm9keS5mcm9tRmlsZSgnd29ya2Zsb3cuYXNsLnlhbWwnKSxcbiAqICAgLy8gdHJhY2luZyBlbmFibGVkIGFuZCBsb2dnaW5nIGNvbmZpZ3VyZWQgYXV0b21hdGljYWxseSBmb3IgRVhQUkVTU1xuICogfSk7XG4gKiBgYGBcbiAqXG4gKiBAc2VlIGh0dHBzOi8vZG9jcy5hd3MuYW1hem9uLmNvbS9jZGsvYXBpL3YyL2RvY3MvYXdzLWNkay1saWIuYXdzX3N0ZXBmdW5jdGlvbnMuU3RhdGVNYWNoaW5lLmh0bWxcbiAqL1xuZXhwb3J0IGNsYXNzIFN0ZXBGdW5jdGlvbnNEZWZhdWx0c0FzcGVjdCBpbXBsZW1lbnRzIElBc3BlY3Qge1xuICAvKipcbiAgICogVmlzaXRzIGEgY29uc3RydWN0IGFuZCBhcHBsaWVzIHRyYWNpbmcgYW5kIGxvZ2dpbmcgc2V0dGluZ3MgaWYgaXQncyBhIFN0YXRlTWFjaGluZVxuICAgKlxuICAgKiBFbmFibGVzIFgtUmF5IHRyYWNpbmcgZm9yIGFsbCBzdGF0ZSBtYWNoaW5lcy4gRm9yIEVYUFJFU1Mgc3RhdGUgbWFjaGluZXMgdGhhdCBkb24ndFxuICAgKiBhbHJlYWR5IGhhdmUgbG9nZ2luZyBjb25maWd1cmVkLCBhdXRvbWF0aWNhbGx5IGNyZWF0ZXMgbG9nIGdyb3VwcyBhbmQgY29uZmlndXJlc1xuICAgKiBjb21wcmVoZW5zaXZlIGxvZ2dpbmcgd2l0aCBmdWxsIGV4ZWN1dGlvbiBkYXRhIGNhcHR1cmUuXG4gICAqXG4gICAqIEBwYXJhbSBub2RlIC0gVGhlIGNvbnN0cnVjdCB0byBwb3RlbnRpYWxseSBtb2RpZnlcbiAgICovXG4gIHZpc2l0KG5vZGU6IElDb25zdHJ1Y3QpOiB2b2lkIHtcbiAgICBpZiAobm9kZSBpbnN0YW5jZW9mIFN0YXRlTWFjaGluZSkge1xuICAgICAgY29uc3QgY2ZuU3RhdGVNYWNoaW5lID0gbm9kZS5ub2RlLmRlZmF1bHRDaGlsZCBhcyBDZm5TdGF0ZU1hY2hpbmU7XG5cbiAgICAgIGlmIChjZm5TdGF0ZU1hY2hpbmUpIHtcbiAgICAgICAgLy8gQXBwbHkgdHJhY2luZyBpZiBub3QgYWxyZWFkeSBzZXRcbiAgICAgICAgaWYgKGNmblN0YXRlTWFjaGluZS50cmFjaW5nQ29uZmlndXJhdGlvbiA9PT0gdW5kZWZpbmVkKSB7XG4gICAgICAgICAgY2ZuU3RhdGVNYWNoaW5lLnRyYWNpbmdDb25maWd1cmF0aW9uID0ge1xuICAgICAgICAgICAgZW5hYmxlZDogdHJ1ZSxcbiAgICAgICAgICB9O1xuICAgICAgICB9XG5cbiAgICAgICAgLy8gRm9yIEVYUFJFU1Mgc3RhdGUgbWFjaGluZXMsIGNvbmZpZ3VyZSBsb2dnaW5nIGlmIG5vdCBhbHJlYWR5IHNldFxuICAgICAgICBpZiAoXG4gICAgICAgICAgY2ZuU3RhdGVNYWNoaW5lLnN0YXRlTWFjaGluZVR5cGUgPT09IFN0YXRlTWFjaGluZVR5cGUuRVhQUkVTUyAmJlxuICAgICAgICAgIGNmblN0YXRlTWFjaGluZS5sb2dnaW5nQ29uZmlndXJhdGlvbiA9PT0gdW5kZWZpbmVkXG4gICAgICAgICkge1xuICAgICAgICAgIGNvbnN0IGxvZ0dyb3VwID0gbmV3IExvZ0dyb3VwKG5vZGUsIFwiTG9nR3JvdXBcIiwge1xuICAgICAgICAgICAgbG9nR3JvdXBOYW1lOiBgL2F3cy92ZW5kZWRsb2dzL3N0YXRlcy8ke25vZGUubm9kZS5pZH1gLFxuICAgICAgICAgIH0pO1xuXG4gICAgICAgICAgY2ZuU3RhdGVNYWNoaW5lLmxvZ2dpbmdDb25maWd1cmF0aW9uID0ge1xuICAgICAgICAgICAgZGVzdGluYXRpb25zOiBbXG4gICAgICAgICAgICAgIHtcbiAgICAgICAgICAgICAgICBjbG91ZFdhdGNoTG9nc0xvZ0dyb3VwOiB7XG4gICAgICAgICAgICAgICAgICBsb2dHcm91cEFybjogbG9nR3JvdXAubG9nR3JvdXBBcm4sXG4gICAgICAgICAgICAgICAgfSxcbiAgICAgICAgICAgICAgfSxcbiAgICAgICAgICAgIF0sXG4gICAgICAgICAgICBsZXZlbDogTG9nTGV2ZWwuQUxMLFxuICAgICAgICAgICAgaW5jbHVkZUV4ZWN1dGlvbkRhdGE6IHRydWUsXG4gICAgICAgICAgfTtcblxuICAgICAgICAgIC8vIEdyYW50IHRoZSBzdGF0ZSBtYWNoaW5lIHJvbGUgdGhlIHBlcm1pc3Npb25zIHJlcXVpcmVkIHRvIGRlbGl2ZXIgbG9ncy5cbiAgICAgICAgICAvLyBNaXJyb3JzIHdoYXQgQ0RLJ3MgU3RhdGVNYWNoaW5lLmJ1aWxkTG9nZ2luZ0NvbmZpZ3VyYXRpb24oKSBkb2VzIGludGVybmFsbHkuXG4gICAgICAgICAgLy9cbiAgICAgICAgICAvLyByZXNvdXJjZXM6IFtcIipcIl0gaXMgaW50ZW50aW9uYWwg4oCUIGFsbCBlaWdodCBhY3Rpb25zIGFyZSB2ZW5kZWQtbG9nLWRlbGl2ZXJ5XG4gICAgICAgICAgLy8gY29udHJvbC1wbGFuZSBBUElzIHRoYXQgb3BlcmF0ZSBhdCB0aGUgYWNjb3VudCBsZXZlbCBhbmQgZG8gbm90IHN1cHBvcnRcbiAgICAgICAgICAvLyByZXNvdXJjZS1sZXZlbCBzY29waW5nIGFnYWluc3QgYSBzcGVjaWZpYyBsb2cgZ3JvdXAgQVJOLlxuICAgICAgICAgIC8vIFNlZTogaHR0cHM6Ly9kb2NzLmF3cy5hbWF6b24uY29tL3NlcnZpY2UtYXV0aG9yaXphdGlvbi9sYXRlc3QvcmVmZXJlbmNlL2xpc3RfYW1hem9uY2xvdWR3YXRjaGxvZ3MuaHRtbFxuICAgICAgICAgIC8vICAgICAgaHR0cHM6Ly9kb2NzLmF3cy5hbWF6b24uY29tL3N0ZXAtZnVuY3Rpb25zL2xhdGVzdC9kZy9jdy1sb2dzLmh0bWxcbiAgICAgICAgICBub2RlLmFkZFRvUm9sZVBvbGljeShcbiAgICAgICAgICAgIG5ldyBQb2xpY3lTdGF0ZW1lbnQoe1xuICAgICAgICAgICAgICBlZmZlY3Q6IEVmZmVjdC5BTExPVyxcbiAgICAgICAgICAgICAgYWN0aW9uczogW1xuICAgICAgICAgICAgICAgIFwibG9nczpDcmVhdGVMb2dEZWxpdmVyeVwiLFxuICAgICAgICAgICAgICAgIFwibG9nczpHZXRMb2dEZWxpdmVyeVwiLFxuICAgICAgICAgICAgICAgIFwibG9nczpVcGRhdGVMb2dEZWxpdmVyeVwiLFxuICAgICAgICAgICAgICAgIFwibG9nczpEZWxldGVMb2dEZWxpdmVyeVwiLFxuICAgICAgICAgICAgICAgIFwibG9nczpMaXN0TG9nRGVsaXZlcmllc1wiLFxuICAgICAgICAgICAgICAgIFwibG9nczpQdXRSZXNvdXJjZVBvbGljeVwiLFxuICAgICAgICAgICAgICAgIFwibG9nczpEZXNjcmliZVJlc291cmNlUG9saWNpZXNcIixcbiAgICAgICAgICAgICAgICBcImxvZ3M6RGVzY3JpYmVMb2dHcm91cHNcIixcbiAgICAgICAgICAgICAgXSxcbiAgICAgICAgICAgICAgcmVzb3VyY2VzOiBbXCIqXCJdLFxuICAgICAgICAgICAgfSlcbiAgICAgICAgICApO1xuICAgICAgICB9XG4gICAgICB9XG4gICAgfVxuICB9XG59XG4iXX0=

package/lib/resource-prefix.d.ts

@@ -61,8 +61,13 @@ export declare class ResourcePrefixAspect implements IAspect {
      */
     private buildPrefixedName;
     /**
-     * Validates resource-specific naming requirements that AWS enforces.
-     * Throws synthesis errors for violations.
+     * Truncates a prefixed name to fit within maxLength by hashing the original
+     * for uniqueness. Emits a CDK warning when truncation occurs.
+     */
+    private truncateToFit;
+    /**
+     * Validates resource-specific structural naming requirements that AWS enforces.
+     * Length violations are handled upstream by truncateToFit.
      */
     private validateResourceName;
 }

package/lib/resource-prefix.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ResourcePrefixAspect = void 0;
+const crypto_1 = require("crypto");
 const aws_cdk_lib_1 = require("aws-cdk-lib");
 /**
  * Maps CloudFormation resource types to their name property and AWS length limits.
@@ -108,8 +109,11 @@ class ResourcePrefixAspect {
         if (this.isAlreadyPrefixed(baseName)) {
             return;
         }
-        const finalName = this.buildPrefixedName(baseName, resourceType, cfnProperties);
-        const hasError = this.validateResourceName(finalName, resourceType, maxLength, node);
+        const prefixedName = this.buildPrefixedName(baseName, resourceType, cfnProperties);
+        // Truncation applies to all overflows — including user-set names — because L3
+        // constructs can generate names the user has no direct control over.
+        const finalName = this.truncateToFit(prefixedName, maxLength, node);
+        const hasError = this.validateResourceName(finalName, resourceType, node);
         if (hasError)
             return;
         node.addPropertyOverride(cfnName, finalName);
@@ -156,12 +160,29 @@ class ResourcePrefixAspect {
         return `${this.prefix}-${baseName}`;
     }
     /**
-     * Validates resource-specific naming requirements that AWS enforces.
-     * Throws synthesis errors for violations.
+     * Truncates a prefixed name to fit within maxLength by hashing the original
+     * for uniqueness. Emits a CDK warning when truncation occurs.
      */
-    validateResourceName(name, cfnResourceType, maxLength, node) {
+    truncateToFit(name, maxLength, node) {
+        if (name.length <= maxLength)
+            return name;
+        const hash = (0, crypto_1.createHash)("sha256").update(name).digest("hex").slice(0, 8);
+        // Preserve .fifo suffix — AWS requires it at the end of FIFO resource names
+        const suffix = name.endsWith(".fifo") ? ".fifo" : "";
+        const nameWithoutSuffix = suffix ? name.slice(0, -suffix.length) : name;
+        // 1 accounts for the dash separator before the hash
+        const budget = maxLength - hash.length - 1 - suffix.length;
+        const truncated = nameWithoutSuffix.slice(0, budget) + "-" + hash + suffix;
+        aws_cdk_lib_1.Annotations.of(node).addWarning(`[ResourcePrefixAspect] "${name}" (${name.length} chars) exceeds the maximum allowed length of ${maxLength}. ` +
+            `Name has been truncated to "${truncated}". Shorten the resource base name or your prefix ("${this.prefix}") to avoid truncation.`);
+        return truncated;
+    }
+    /**
+     * Validates resource-specific structural naming requirements that AWS enforces.
+     * Length violations are handled upstream by truncateToFit.
+     */
+    validateResourceName(name, cfnResourceType, node) {
         let hasError = false;
-        // S3 bucket names cannot contain underscores
         if (cfnResourceType === "AWS::S3::Bucket") {
             if (name !== name.toLowerCase()) {
                 aws_cdk_lib_1.Annotations.of(node).addError(`[ResourcePrefixAspect] S3 bucket name "${name}" contains uppercase letters. ` +
@@ -174,14 +195,8 @@ class ResourcePrefixAspect {
                 hasError = true;
             }
         }
-        if (name.length > maxLength) {
-            aws_cdk_lib_1.Annotations.of(node).addError(`[ResourcePrefixAspect] "${name}" (${name.length} chars) exceeds the ` +
-                `maximum allowed length of ${maxLength} for ${cfnResourceType}. ` +
-                `Shorten the resource base name or your prefix ("${this.prefix}").`);
-            hasError = true;
-        }
         return hasError;
     }
 }
 exports.ResourcePrefixAspect = ResourcePrefixAspect;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"resource-prefix.js","sourceRoot":"","sources":["resource-prefix.ts"],"names":[],"mappings":"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","sourcesContent":["import { Annotations, CfnResource, IAspect, Stack } from \"aws-cdk-lib\";\nimport { IConstruct } from \"constructs\";\n\ninterface ResourceNameConfig {\n  /** The CloudFormation property that holds the resource's physical name */\n  cfnName: string;\n  /** Maximum allowed character length for this resource type */\n  maxLength: number;\n}\n\n/**\n * Extension type to access internal CloudFormation properties on CfnResource.\n *\n * CDK does not provide a public API to read raw CloudFormation properties that have\n * been set on a CfnResource. The properties `_cfnProperties` and `cfnProperties` are\n * protected and only accessible within the CfnResource class hierarchy.\n *\n * We investigated using CDK's public APIs, but there is no public method to retrieve\n * the raw property values that have been set (e.g., via constructor props or addPropertyOverride).\n * The only public APIs are for writing (addPropertyOverride, addPropertyDeletionOverride) or\n * getting attribute references (getAtt), not for reading literal property values.\n *\n * This type assertion is safe because:\n * - We only read these properties, never modify them\n * - We need to check if a user explicitly set a name property before applying our prefix\n * - The properties exist at runtime and are part of CDK's internal implementation\n */\ntype CfnResourceWithProps = CfnResource & {\n  readonly _cfnProperties?: Record<string, unknown>;\n  readonly cfnProperties?: Record<string, unknown>;\n};\n\n/**\n * Maps CloudFormation resource types to their name property and AWS length limits.\n * Sources: https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-template-resource-type-ref.html\n */\nconst RESOURCE_CONFIG: Record<string, ResourceNameConfig> = {\n  // Compute\n  \"AWS::Lambda::Function\": { cfnName: \"FunctionName\", maxLength: 64 },\n\n  // Storage\n  \"AWS::S3::Bucket\": { cfnName: \"BucketName\", maxLength: 63 },\n  \"AWS::DynamoDB::Table\": { cfnName: \"TableName\", maxLength: 255 },\n  \"AWS::DynamoDB::GlobalTable\": { cfnName: \"TableName\", maxLength: 255 },\n\n  // Messaging\n  \"AWS::SQS::Queue\": { cfnName: \"QueueName\", maxLength: 80 },\n  \"AWS::SNS::Topic\": { cfnName: \"TopicName\", maxLength: 256 },\n\n  // Eventing & Orchestration\n  \"AWS::Events::EventBus\": { cfnName: \"Name\", maxLength: 256 },\n  \"AWS::Events::Rule\": { cfnName: \"Name\", maxLength: 64 },\n  \"AWS::Events::Connection\": { cfnName: \"Name\", maxLength: 64 },\n  \"AWS::Pipes::Pipe\": { cfnName: \"Name\", maxLength: 64 },\n  \"AWS::StepFunctions::StateMachine\": {\n    cfnName: \"StateMachineName\",\n    maxLength: 80,\n  },\n  \"AWS::StepFunctions::Activity\": { cfnName: \"Name\", maxLength: 80 },\n  \"AWS::Scheduler::Schedule\": { cfnName: \"Name\", maxLength: 64 },\n  \"AWS::Scheduler::ScheduleGroup\": { cfnName: \"Name\", maxLength: 64 },\n\n  // API\n  \"AWS::ApiGateway::RestApi\": { cfnName: \"Name\", maxLength: 128 },\n  \"AWS::ApiGateway::UsagePlan\": { cfnName: \"UsagePlanName\", maxLength: 128 },\n  \"AWS::ApiGateway::ApiKey\": { cfnName: \"Name\", maxLength: 128 },\n  \"AWS::ApiGatewayV2::Api\": { cfnName: \"Name\", maxLength: 128 },\n  \"AWS::ApiGatewayV2::Authorizer\": { cfnName: \"Name\", maxLength: 128 },\n\n  // Secrets & Config\n  \"AWS::SecretsManager::Secret\": { cfnName: \"Name\", maxLength: 512 },\n  \"AWS::SSM::Parameter\": { cfnName: \"Name\", maxLength: 2048 },\n  \"AWS::AppConfig::Application\": { cfnName: \"Name\", maxLength: 64 },\n  \"AWS::AppConfig::Environment\": { cfnName: \"Name\", maxLength: 64 },\n\n  // Notifications\n  \"AWS::Notifications::NotificationConfiguration\": {\n    cfnName: \"Name\",\n    maxLength: 64,\n  },\n\n  // Observability\n  \"AWS::Logs::LogGroup\": { cfnName: \"LogGroupName\", maxLength: 512 },\n  \"AWS::CloudWatch::Alarm\": { cfnName: \"AlarmName\", maxLength: 255 },\n\n  // IAM\n  \"AWS::IAM::Role\": { cfnName: \"RoleName\", maxLength: 64 },\n};\n\nexport interface ResourcePrefixAspectProps {\n  /**\n   * The prefix to apply to all resource names.\n   * e.g. 'myapp-prod' → 'myapp-prod-orders'\n   */\n  prefix: string;\n\n  /**\n   * Resource types to skip entirely.\n   * e.g. ['AWS::IAM::Role'] to leave IAM role names untouched.\n   * @default []\n   */\n  exclude?: string[];\n}\n\n/**\n * CDK Aspect that automatically prefixes physical resource names across AWS resources.\n *\n * @remarks\n * **Critical Implementation Notes:**\n *\n * 1. **Stage Synthesis Boundaries**:\n *    - CDK `Stage` constructs create synthesis boundaries that prevent App-level aspects\n *      from traversing into them\n *    - This aspect MUST be applied to each Stage individually, not to the App\n *    - Example: `Aspects.of(stage).add(new ResourcePrefixAspect({...}))`\n *\n * 2. **Property Name Casing**:\n *    - CloudFormation properties use PascalCase (e.g., `FunctionName`, `BucketName`)\n *    - Using camelCase (e.g., `functionName`) will cause errors with versioning aspects\n *    - When using `addPropertyOverride()`, always use the exact CloudFormation property name\n *\n * 3. **Aspect Priority with Versioning**:\n *    - When combining with LambdaAndStepFunctionVersioningAspect, apply this aspect BEFORE versioning\n *    - Use CDK's priority system: `Aspects.of(stage).add(prefixAspect, { priority: 100 })`\n *    - Then: `Aspects.of(stage).add(versioningAspect, { priority: 200 })`\n *    - Lower priority numbers run first\n *\n * @example\n * ```typescript\n * // Correct usage with staging\n * const stage = new ApplicationStage(app, 'prod');\n * Aspects.of(stage).add(new ResourcePrefixAspect({ prefix: 'myapp' }), { priority: 100 });\n * Aspects.of(stage).add(new LambdaAndStepFunctionVersioningAspect(), { priority: 200 });\n * ```\n */\nexport class ResourcePrefixAspect implements IAspect {\n  private readonly prefix: string;\n  private readonly exclude: Set<string>;\n\n  constructor(props: ResourcePrefixAspectProps) {\n    if (!props.prefix || !/^[a-z0-9-]+$/.test(props.prefix))\n      throw new Error(\n        `ResourcePrefixAspect: prefix must contain only lowercase alphanumeric characters and hyphens, got \"${props.prefix}\"`\n      );\n\n    this.prefix = props.prefix;\n    this.exclude = new Set(props.exclude ?? []);\n  }\n\n  visit(node: IConstruct) {\n    if (!(node instanceof CfnResource)) return;\n\n    const resourceType = node.cfnResourceType;\n    const config = RESOURCE_CONFIG[resourceType];\n\n    if (!config || this.exclude.has(resourceType)) {\n      return;\n    }\n\n    const { cfnName, maxLength } = config;\n    const cfnProperties: Record<string, unknown> =\n      (node as CfnResourceWithProps)._cfnProperties ??\n      (node as CfnResourceWithProps).cfnProperties ??\n      {};\n\n    // Get any explicitly set name, or derive one from the logical ID\n    const existingName =\n      typeof cfnProperties[cfnName] === \"string\"\n        ? cfnProperties[cfnName]\n        : undefined;\n    const baseName = existingName ?? this.deriveNameFromLogicalId(node);\n\n    if (this.isAlreadyPrefixed(baseName)) {\n      return;\n    }\n\n    const finalName = this.buildPrefixedName(\n      baseName,\n      resourceType,\n      cfnProperties\n    );\n\n    const hasError = this.validateResourceName(\n      finalName,\n      resourceType,\n      maxLength,\n      node\n    );\n\n    if (hasError) return;\n\n    node.addPropertyOverride(cfnName, finalName);\n  }\n\n  private isAlreadyPrefixed(name: string): boolean {\n    return (\n      name.startsWith(`${this.prefix}-`) || name.startsWith(`/${this.prefix}/`)\n    );\n  }\n\n  private deriveNameFromLogicalId(node: CfnResource) {\n    const logicalId = Stack.of(node).getLogicalId(node);\n    return logicalId\n      .replace(/[^a-zA-Z0-9]+/g, \"-\") // non-alphanumeric → dash\n      .replace(/^-+|-+$/g, \"\"); // trim leading/trailing dashes\n  }\n\n  /**\n   * Builds the prefixed name, handling special cases for specific resource types.\n   *\n   * @param baseName - The base resource name (without prefix)\n   * @param cfnResourceType - The CloudFormation resource type\n   * @param cfnProperties - The CloudFormation resource properties\n   * @returns The final prefixed name with any special case handling applied\n   */\n  private buildPrefixedName(\n    baseName: string,\n    cfnResourceType: string,\n    cfnProperties: Record<string, unknown>\n  ): string {\n    // Special case: FIFO queues must end with .fifo suffix\n    if (\n      cfnResourceType === \"AWS::SQS::Queue\" &&\n      cfnProperties.fifoQueue === true &&\n      !baseName.endsWith(\".fifo\")\n    ) {\n      return `${this.prefix}-${baseName}.fifo`;\n    }\n\n    // Special case: FIFO topics must end with .fifo suffix\n    if (\n      cfnResourceType === \"AWS::SNS::Topic\" &&\n      cfnProperties.fifoTopic === true &&\n      !baseName.endsWith(\".fifo\")\n    ) {\n      return `${this.prefix}-${baseName}.fifo`;\n    }\n\n    // Special case: SSM parameter names use path-style prefix\n    if (cfnResourceType === \"AWS::SSM::Parameter\") {\n      return `/${this.prefix}/${baseName}`;\n    }\n\n    // Special case: S3 bucket name be lowercase only\n    if (cfnResourceType === \"AWS::S3::Bucket\") {\n      return `${this.prefix}-${baseName}`.toLowerCase();\n    }\n\n    // Default: simple prefix\n    return `${this.prefix}-${baseName}`;\n  }\n\n  /**\n   * Validates resource-specific naming requirements that AWS enforces.\n   * Throws synthesis errors for violations.\n   */\n  private validateResourceName(\n    name: string,\n    cfnResourceType: string,\n    maxLength: number,\n    node: IConstruct\n  ): boolean {\n    let hasError = false;\n\n    // S3 bucket names cannot contain underscores\n    if (cfnResourceType === \"AWS::S3::Bucket\") {\n      if (name !== name.toLowerCase()) {\n        Annotations.of(node).addError(\n          `[ResourcePrefixAspect] S3 bucket name \"${name}\" contains uppercase letters. ` +\n            `Bucket names must be lowercase only.`\n        );\n        hasError = true;\n      }\n\n      if (name.includes(\"_\")) {\n        Annotations.of(node).addError(\n          `[ResourcePrefixAspect] S3 bucket name \"${name}\" contains underscores. ` +\n            `Bucket names cannot contain underscores. Use hyphens instead.`\n        );\n        hasError = true;\n      }\n    }\n\n    if (name.length > maxLength) {\n      Annotations.of(node).addError(\n        `[ResourcePrefixAspect] \"${name}\" (${name.length} chars) exceeds the ` +\n          `maximum allowed length of ${maxLength} for ${cfnResourceType}. ` +\n          `Shorten the resource base name or your prefix (\"${this.prefix}\").`\n      );\n      hasError = true;\n    }\n\n    return hasError;\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"resource-prefix.js","sourceRoot":"","sources":["resource-prefix.ts"],"names":[],"mappings":"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","sourcesContent":["import { createHash } from \"crypto\";\nimport { Annotations, CfnResource, IAspect, Stack } from \"aws-cdk-lib\";\nimport { IConstruct } from \"constructs\";\n\ninterface ResourceNameConfig {\n  /** The CloudFormation property that holds the resource's physical name */\n  cfnName: string;\n  /** Maximum allowed character length for this resource type */\n  maxLength: number;\n}\n\n/**\n * Extension type to access internal CloudFormation properties on CfnResource.\n *\n * CDK does not provide a public API to read raw CloudFormation properties that have\n * been set on a CfnResource. The properties `_cfnProperties` and `cfnProperties` are\n * protected and only accessible within the CfnResource class hierarchy.\n *\n * We investigated using CDK's public APIs, but there is no public method to retrieve\n * the raw property values that have been set (e.g., via constructor props or addPropertyOverride).\n * The only public APIs are for writing (addPropertyOverride, addPropertyDeletionOverride) or\n * getting attribute references (getAtt), not for reading literal property values.\n *\n * This type assertion is safe because:\n * - We only read these properties, never modify them\n * - We need to check if a user explicitly set a name property before applying our prefix\n * - The properties exist at runtime and are part of CDK's internal implementation\n */\ntype CfnResourceWithProps = CfnResource & {\n  readonly _cfnProperties?: Record<string, unknown>;\n  readonly cfnProperties?: Record<string, unknown>;\n};\n\n/**\n * Maps CloudFormation resource types to their name property and AWS length limits.\n * Sources: https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-template-resource-type-ref.html\n */\nconst RESOURCE_CONFIG: Record<string, ResourceNameConfig> = {\n  // Compute\n  \"AWS::Lambda::Function\": { cfnName: \"FunctionName\", maxLength: 64 },\n\n  // Storage\n  \"AWS::S3::Bucket\": { cfnName: \"BucketName\", maxLength: 63 },\n  \"AWS::DynamoDB::Table\": { cfnName: \"TableName\", maxLength: 255 },\n  \"AWS::DynamoDB::GlobalTable\": { cfnName: \"TableName\", maxLength: 255 },\n\n  // Messaging\n  \"AWS::SQS::Queue\": { cfnName: \"QueueName\", maxLength: 80 },\n  \"AWS::SNS::Topic\": { cfnName: \"TopicName\", maxLength: 256 },\n\n  // Eventing & Orchestration\n  \"AWS::Events::EventBus\": { cfnName: \"Name\", maxLength: 256 },\n  \"AWS::Events::Rule\": { cfnName: \"Name\", maxLength: 64 },\n  \"AWS::Events::Connection\": { cfnName: \"Name\", maxLength: 64 },\n  \"AWS::Pipes::Pipe\": { cfnName: \"Name\", maxLength: 64 },\n  \"AWS::StepFunctions::StateMachine\": {\n    cfnName: \"StateMachineName\",\n    maxLength: 80,\n  },\n  \"AWS::StepFunctions::Activity\": { cfnName: \"Name\", maxLength: 80 },\n  \"AWS::Scheduler::Schedule\": { cfnName: \"Name\", maxLength: 64 },\n  \"AWS::Scheduler::ScheduleGroup\": { cfnName: \"Name\", maxLength: 64 },\n\n  // API\n  \"AWS::ApiGateway::RestApi\": { cfnName: \"Name\", maxLength: 128 },\n  \"AWS::ApiGateway::UsagePlan\": { cfnName: \"UsagePlanName\", maxLength: 128 },\n  \"AWS::ApiGateway::ApiKey\": { cfnName: \"Name\", maxLength: 128 },\n  \"AWS::ApiGatewayV2::Api\": { cfnName: \"Name\", maxLength: 128 },\n  \"AWS::ApiGatewayV2::Authorizer\": { cfnName: \"Name\", maxLength: 128 },\n\n  // Secrets & Config\n  \"AWS::SecretsManager::Secret\": { cfnName: \"Name\", maxLength: 512 },\n  \"AWS::SSM::Parameter\": { cfnName: \"Name\", maxLength: 2048 },\n  \"AWS::AppConfig::Application\": { cfnName: \"Name\", maxLength: 64 },\n  \"AWS::AppConfig::Environment\": { cfnName: \"Name\", maxLength: 64 },\n\n  // Notifications\n  \"AWS::Notifications::NotificationConfiguration\": {\n    cfnName: \"Name\",\n    maxLength: 64,\n  },\n\n  // Observability\n  \"AWS::Logs::LogGroup\": { cfnName: \"LogGroupName\", maxLength: 512 },\n  \"AWS::CloudWatch::Alarm\": { cfnName: \"AlarmName\", maxLength: 255 },\n\n  // IAM\n  \"AWS::IAM::Role\": { cfnName: \"RoleName\", maxLength: 64 },\n};\n\nexport interface ResourcePrefixAspectProps {\n  /**\n   * The prefix to apply to all resource names.\n   * e.g. 'myapp-prod' → 'myapp-prod-orders'\n   */\n  prefix: string;\n\n  /**\n   * Resource types to skip entirely.\n   * e.g. ['AWS::IAM::Role'] to leave IAM role names untouched.\n   * @default []\n   */\n  exclude?: string[];\n}\n\n/**\n * CDK Aspect that automatically prefixes physical resource names across AWS resources.\n *\n * @remarks\n * **Critical Implementation Notes:**\n *\n * 1. **Stage Synthesis Boundaries**:\n *    - CDK `Stage` constructs create synthesis boundaries that prevent App-level aspects\n *      from traversing into them\n *    - This aspect MUST be applied to each Stage individually, not to the App\n *    - Example: `Aspects.of(stage).add(new ResourcePrefixAspect({...}))`\n *\n * 2. **Property Name Casing**:\n *    - CloudFormation properties use PascalCase (e.g., `FunctionName`, `BucketName`)\n *    - Using camelCase (e.g., `functionName`) will cause errors with versioning aspects\n *    - When using `addPropertyOverride()`, always use the exact CloudFormation property name\n *\n * 3. **Aspect Priority with Versioning**:\n *    - When combining with LambdaAndStepFunctionVersioningAspect, apply this aspect BEFORE versioning\n *    - Use CDK's priority system: `Aspects.of(stage).add(prefixAspect, { priority: 100 })`\n *    - Then: `Aspects.of(stage).add(versioningAspect, { priority: 200 })`\n *    - Lower priority numbers run first\n *\n * @example\n * ```typescript\n * // Correct usage with staging\n * const stage = new ApplicationStage(app, 'prod');\n * Aspects.of(stage).add(new ResourcePrefixAspect({ prefix: 'myapp' }), { priority: 100 });\n * Aspects.of(stage).add(new LambdaAndStepFunctionVersioningAspect(), { priority: 200 });\n * ```\n */\nexport class ResourcePrefixAspect implements IAspect {\n  private readonly prefix: string;\n  private readonly exclude: Set<string>;\n\n  constructor(props: ResourcePrefixAspectProps) {\n    if (!props.prefix || !/^[a-z0-9-]+$/.test(props.prefix))\n      throw new Error(\n        `ResourcePrefixAspect: prefix must contain only lowercase alphanumeric characters and hyphens, got \"${props.prefix}\"`\n      );\n\n    this.prefix = props.prefix;\n    this.exclude = new Set(props.exclude ?? []);\n  }\n\n  visit(node: IConstruct) {\n    if (!(node instanceof CfnResource)) return;\n\n    const resourceType = node.cfnResourceType;\n    const config = RESOURCE_CONFIG[resourceType];\n\n    if (!config || this.exclude.has(resourceType)) {\n      return;\n    }\n\n    const { cfnName, maxLength } = config;\n    const cfnProperties: Record<string, unknown> =\n      (node as CfnResourceWithProps)._cfnProperties ??\n      (node as CfnResourceWithProps).cfnProperties ??\n      {};\n\n    // Get any explicitly set name, or derive one from the logical ID\n    const existingName =\n      typeof cfnProperties[cfnName] === \"string\"\n        ? cfnProperties[cfnName]\n        : undefined;\n    const baseName = existingName ?? this.deriveNameFromLogicalId(node);\n\n    if (this.isAlreadyPrefixed(baseName)) {\n      return;\n    }\n\n    const prefixedName = this.buildPrefixedName(\n      baseName,\n      resourceType,\n      cfnProperties\n    );\n\n    // Truncation applies to all overflows — including user-set names — because L3\n    // constructs can generate names the user has no direct control over.\n    const finalName = this.truncateToFit(prefixedName, maxLength, node);\n\n    const hasError = this.validateResourceName(finalName, resourceType, node);\n\n    if (hasError) return;\n\n    node.addPropertyOverride(cfnName, finalName);\n  }\n\n  private isAlreadyPrefixed(name: string): boolean {\n    return (\n      name.startsWith(`${this.prefix}-`) || name.startsWith(`/${this.prefix}/`)\n    );\n  }\n\n  private deriveNameFromLogicalId(node: CfnResource) {\n    const logicalId = Stack.of(node).getLogicalId(node);\n    return logicalId\n      .replace(/[^a-zA-Z0-9]+/g, \"-\") // non-alphanumeric → dash\n      .replace(/^-+|-+$/g, \"\"); // trim leading/trailing dashes\n  }\n\n  /**\n   * Builds the prefixed name, handling special cases for specific resource types.\n   *\n   * @param baseName - The base resource name (without prefix)\n   * @param cfnResourceType - The CloudFormation resource type\n   * @param cfnProperties - The CloudFormation resource properties\n   * @returns The final prefixed name with any special case handling applied\n   */\n  private buildPrefixedName(\n    baseName: string,\n    cfnResourceType: string,\n    cfnProperties: Record<string, unknown>\n  ): string {\n    // Special case: FIFO queues must end with .fifo suffix\n    if (\n      cfnResourceType === \"AWS::SQS::Queue\" &&\n      cfnProperties.fifoQueue === true &&\n      !baseName.endsWith(\".fifo\")\n    ) {\n      return `${this.prefix}-${baseName}.fifo`;\n    }\n\n    // Special case: FIFO topics must end with .fifo suffix\n    if (\n      cfnResourceType === \"AWS::SNS::Topic\" &&\n      cfnProperties.fifoTopic === true &&\n      !baseName.endsWith(\".fifo\")\n    ) {\n      return `${this.prefix}-${baseName}.fifo`;\n    }\n\n    // Special case: SSM parameter names use path-style prefix\n    if (cfnResourceType === \"AWS::SSM::Parameter\") {\n      return `/${this.prefix}/${baseName}`;\n    }\n\n    // Special case: S3 bucket name be lowercase only\n    if (cfnResourceType === \"AWS::S3::Bucket\") {\n      return `${this.prefix}-${baseName}`.toLowerCase();\n    }\n\n    // Default: simple prefix\n    return `${this.prefix}-${baseName}`;\n  }\n\n  /**\n   * Truncates a prefixed name to fit within maxLength by hashing the original\n   * for uniqueness. Emits a CDK warning when truncation occurs.\n   */\n  private truncateToFit(\n    name: string,\n    maxLength: number,\n    node: IConstruct\n  ): string {\n    if (name.length <= maxLength) return name;\n\n    const hash = createHash(\"sha256\").update(name).digest(\"hex\").slice(0, 8);\n\n    // Preserve .fifo suffix — AWS requires it at the end of FIFO resource names\n    const suffix = name.endsWith(\".fifo\") ? \".fifo\" : \"\";\n    const nameWithoutSuffix = suffix ? name.slice(0, -suffix.length) : name;\n\n    // 1 accounts for the dash separator before the hash\n    const budget = maxLength - hash.length - 1 - suffix.length;\n    const truncated = nameWithoutSuffix.slice(0, budget) + \"-\" + hash + suffix;\n\n    Annotations.of(node).addWarning(\n      `[ResourcePrefixAspect] \"${name}\" (${name.length} chars) exceeds the maximum allowed length of ${maxLength}. ` +\n        `Name has been truncated to \"${truncated}\". Shorten the resource base name or your prefix (\"${this.prefix}\") to avoid truncation.`\n    );\n\n    return truncated;\n  }\n\n  /**\n   * Validates resource-specific structural naming requirements that AWS enforces.\n   * Length violations are handled upstream by truncateToFit.\n   */\n  private validateResourceName(\n    name: string,\n    cfnResourceType: string,\n    node: IConstruct\n  ): boolean {\n    let hasError = false;\n\n    if (cfnResourceType === \"AWS::S3::Bucket\") {\n      if (name !== name.toLowerCase()) {\n        Annotations.of(node).addError(\n          `[ResourcePrefixAspect] S3 bucket name \"${name}\" contains uppercase letters. ` +\n            `Bucket names must be lowercase only.`\n        );\n        hasError = true;\n      }\n\n      if (name.includes(\"_\")) {\n        Annotations.of(node).addError(\n          `[ResourcePrefixAspect] S3 bucket name \"${name}\" contains underscores. ` +\n            `Bucket names cannot contain underscores. Use hyphens instead.`\n        );\n        hasError = true;\n      }\n    }\n\n    return hasError;\n  }\n}\n"]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aligent/cdk-aspects",
-  "version": "0.5.2",
+  "version": "0.5.5",
   "description": "Collection of CDK Asppects",
   "main": "index.js",
   "types": "index.d.ts",
@@ -21,14 +21,14 @@
   "devDependencies": {
     "@types/jest": "^29.5.10",
     "@types/node": "^20.19.39",
-    "aws-cdk": "^2.1019.1",
+    "aws-cdk": "^2.1119.0",
     "jest": "^29.7.0",
-    "ts-jest": "^29.1.1",
+    "ts-jest": "^29.4.9",
     "ts-node": "^10.9.1",
     "typescript": "^5.3.2"
   },
   "dependencies": {
-    "aws-cdk-lib": "^2.201.0",
+    "aws-cdk-lib": "^2.251.0",
     "constructs": "^10.5.0",
     "esbuild": "^0.28.0",
     "source-map-support": "^0.5.21"