@aligent/cdk-aspects 0.5.1 → 0.5.3

package/CHANGELOG.md

@@ -1,5 +1,32 @@
 # @aligent/cdk-aspects
 
+## 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
+
+- [#1609](https://github.com/aligent/cdk-constructs/pull/1609) [`ba5bc76`](https://github.com/aligent/cdk-constructs/commit/ba5bc7641349972a11dd8f0f993e236bb270c468) Thanks [@dependabot](https://github.com/apps/dependabot)! - chore(deps): bump esbuild from 0.25.0 to 0.27.3 in the esbuild group across 1 directory
+
 ## 0.5.1
 
 ### 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/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.1",
+  "version": "0.5.3",
   "description": "Collection of CDK Asppects",
   "main": "index.js",
   "types": "index.d.ts",
@@ -30,7 +30,7 @@
   "dependencies": {
     "aws-cdk-lib": "^2.201.0",
     "constructs": "^10.5.0",
-    "esbuild": "^0.18.0",
+    "esbuild": "^0.28.0",
     "source-map-support": "^0.5.21"
   }
 }