@aligent/cdk-aspects 0.3.2 → 0.5.0

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @aligent/cdk-aspects
 
+## 0.5.0
+
+### Minor Changes
+
+- [#1630](https://github.com/aligent/cdk-constructs/pull/1630) [`91347d6`](https://github.com/aligent/cdk-constructs/commit/91347d62e048c23ae85f657e97c1dd357c1b2a70) Thanks [@kai-nguyen-aligent](https://github.com/kai-nguyen-aligent)! - Add default aspects for S3 and DynamoDB resources to enforce secure configuration defaults
+
+## 0.4.0
+
+### Minor Changes
+
+- [#1627](https://github.com/aligent/cdk-constructs/pull/1627) [`a53bad0`](https://github.com/aligent/cdk-constructs/commit/a53bad0c3b8156ec3b57476b4007cdb854785ba6) Thanks [@kai-nguyen-aligent](https://github.com/kai-nguyen-aligent)! - Add new ResourcePrefixAspect
+
 ## 0.3.2
 
 ### Patch Changes

package/index.d.ts

@@ -1,5 +1,8 @@
+export * from "./lib/defaults/dynamodb";
 export * from "./lib/defaults/log-group";
 export * from "./lib/defaults/nodejs-function";
+export * from "./lib/defaults/s3-bucket";
 export * from "./lib/defaults/step-functions";
 export * from "./lib/lambda-sfn-versioning";
 export * from "./lib/microservice-checks";
+export * from "./lib/resource-prefix";

package/index.js

@@ -14,9 +14,12 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./lib/defaults/dynamodb"), exports);
 __exportStar(require("./lib/defaults/log-group"), exports);
 __exportStar(require("./lib/defaults/nodejs-function"), exports);
+__exportStar(require("./lib/defaults/s3-bucket"), exports);
 __exportStar(require("./lib/defaults/step-functions"), exports);
 __exportStar(require("./lib/lambda-sfn-versioning"), exports);
 __exportStar(require("./lib/microservice-checks"), exports);
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyJpbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7O0FBQUEsMkRBQXlDO0FBQ3pDLGlFQUErQztBQUMvQyxnRUFBOEM7QUFDOUMsOERBQTRDO0FBQzVDLDREQUEwQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gXCIuL2xpYi9kZWZhdWx0cy9sb2ctZ3JvdXBcIjtcbmV4cG9ydCAqIGZyb20gXCIuL2xpYi9kZWZhdWx0cy9ub2RlanMtZnVuY3Rpb25cIjtcbmV4cG9ydCAqIGZyb20gXCIuL2xpYi9kZWZhdWx0cy9zdGVwLWZ1bmN0aW9uc1wiO1xuZXhwb3J0ICogZnJvbSBcIi4vbGliL2xhbWJkYS1zZm4tdmVyc2lvbmluZ1wiO1xuZXhwb3J0ICogZnJvbSBcIi4vbGliL21pY3Jvc2VydmljZS1jaGVja3NcIjtcbiJdfQ==
+__exportStar(require("./lib/resource-prefix"), exports);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyJpbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7O0FBQUEsMERBQXdDO0FBQ3hDLDJEQUF5QztBQUN6QyxpRUFBK0M7QUFDL0MsMkRBQXlDO0FBQ3pDLGdFQUE4QztBQUM5Qyw4REFBNEM7QUFDNUMsNERBQTBDO0FBQzFDLHdEQUFzQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gXCIuL2xpYi9kZWZhdWx0cy9keW5hbW9kYlwiO1xuZXhwb3J0ICogZnJvbSBcIi4vbGliL2RlZmF1bHRzL2xvZy1ncm91cFwiO1xuZXhwb3J0ICogZnJvbSBcIi4vbGliL2RlZmF1bHRzL25vZGVqcy1mdW5jdGlvblwiO1xuZXhwb3J0ICogZnJvbSBcIi4vbGliL2RlZmF1bHRzL3MzLWJ1Y2tldFwiO1xuZXhwb3J0ICogZnJvbSBcIi4vbGliL2RlZmF1bHRzL3N0ZXAtZnVuY3Rpb25zXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9saWIvbGFtYmRhLXNmbi12ZXJzaW9uaW5nXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9saWIvbWljcm9zZXJ2aWNlLWNoZWNrc1wiO1xuZXhwb3J0ICogZnJvbSBcIi4vbGliL3Jlc291cmNlLXByZWZpeFwiO1xuIl19

package/lib/defaults/dynamodb.d.ts

@@ -0,0 +1,53 @@
+import { type IAspect } from "aws-cdk-lib";
+import { IConstruct } from "constructs";
+interface Config {
+    duration: "SHORT" | "MEDIUM" | "LONG";
+}
+/**
+ * Aspect that automatically applies configuration-aware defaults to DynamoDB Tables
+ *
+ * Visits all constructs in the scope and automatically applies configuration-specific
+ * removal policies and point-in-time recovery settings to DynamoDB tables.
+ * Different configurations balance between cost optimization and data retention needs.
+ *
+ * @example
+ * ```typescript
+ * // Apply configuration-specific defaults to all tables
+ * Aspects.of(app).add(new DynamoDbDefaultsAspect({ duration: 'SHORT' }));
+ *
+ * // Tables automatically inherit configuration defaults
+ * new Table(stack, 'MyTable', {
+ *   // point-in-time recovery and removal policy applied automatically
+ * });
+ * ```
+ *
+ * @see https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_dynamodb.Table.html
+ */
+export declare class DynamoDbDefaultsAspect implements IAspect {
+    private readonly defaultProps;
+    /**
+     * Creates a new DynamoDbDefaultsAspect
+     *
+     * @param config - Configuration identifier used to select appropriate defaults.
+     */
+    constructor(config: Config);
+    /**
+     * Get duration-specific DynamoDB table properties
+     *
+     * @param duration - The duration to get the table properties for
+     * @returns The table properties for the duration
+     */
+    private retentionProperties;
+    private isProvisionedThroughputConfigured;
+    private isOnDemandThroughputConfigured;
+    /**
+     * Visits a construct and applies configuration-appropriate defaults
+     *
+     * Applies configuration-specific billing mode, throughput, point-in-time recovery,
+     * and removal policies to tables that don't already have these properties explicitly set.
+     *
+     * @param node - The construct to potentially modify
+     */
+    visit(node: IConstruct): void;
+}
+export {};

package/lib/defaults/dynamodb.js

@@ -0,0 +1,114 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DynamoDbDefaultsAspect = void 0;
+const aws_cdk_lib_1 = require("aws-cdk-lib");
+const aws_dynamodb_1 = require("aws-cdk-lib/aws-dynamodb");
+/**
+ * Aspect that automatically applies configuration-aware defaults to DynamoDB Tables
+ *
+ * Visits all constructs in the scope and automatically applies configuration-specific
+ * removal policies and point-in-time recovery settings to DynamoDB tables.
+ * Different configurations balance between cost optimization and data retention needs.
+ *
+ * @example
+ * ```typescript
+ * // Apply configuration-specific defaults to all tables
+ * Aspects.of(app).add(new DynamoDbDefaultsAspect({ duration: 'SHORT' }));
+ *
+ * // Tables automatically inherit configuration defaults
+ * new Table(stack, 'MyTable', {
+ *   // point-in-time recovery and removal policy applied automatically
+ * });
+ * ```
+ *
+ * @see https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_dynamodb.Table.html
+ */
+class DynamoDbDefaultsAspect {
+    /**
+     * Creates a new DynamoDbDefaultsAspect
+     *
+     * @param config - Configuration identifier used to select appropriate defaults.
+     */
+    constructor(config) {
+        this.defaultProps = this.retentionProperties(config.duration);
+    }
+    /**
+     * Get duration-specific DynamoDB table properties
+     *
+     * @param duration - The duration to get the table properties for
+     * @returns The table properties for the duration
+     */
+    retentionProperties(duration) {
+        switch (duration) {
+            case "SHORT":
+                return {
+                    billingMode: aws_dynamodb_1.BillingMode.PROVISIONED,
+                    readCapacity: 1,
+                    writeCapacity: 1,
+                    removalPolicy: aws_cdk_lib_1.RemovalPolicy.DESTROY,
+                };
+            case "MEDIUM":
+                return {
+                    billingMode: aws_dynamodb_1.BillingMode.PAY_PER_REQUEST,
+                    maxReadRequestUnits: 100,
+                    maxWriteRequestUnits: 100,
+                    removalPolicy: aws_cdk_lib_1.RemovalPolicy.DESTROY,
+                };
+            default:
+                return {
+                    billingMode: aws_dynamodb_1.BillingMode.PAY_PER_REQUEST,
+                    removalPolicy: aws_cdk_lib_1.RemovalPolicy.RETAIN,
+                };
+        }
+    }
+    isProvisionedThroughputConfigured() {
+        const { billingMode, readCapacity, writeCapacity } = this.defaultProps;
+        return (billingMode === aws_dynamodb_1.BillingMode.PROVISIONED &&
+            readCapacity !== undefined &&
+            writeCapacity !== undefined);
+    }
+    isOnDemandThroughputConfigured() {
+        const { billingMode, maxReadRequestUnits, maxWriteRequestUnits } = this.defaultProps;
+        return (billingMode === aws_dynamodb_1.BillingMode.PAY_PER_REQUEST &&
+            maxReadRequestUnits !== undefined &&
+            maxWriteRequestUnits !== undefined);
+    }
+    /**
+     * Visits a construct and applies configuration-appropriate defaults
+     *
+     * Applies configuration-specific billing mode, throughput, point-in-time recovery,
+     * and removal policies to tables that don't already have these properties explicitly set.
+     *
+     * @param node - The construct to potentially modify
+     */
+    visit(node) {
+        if (node instanceof aws_dynamodb_1.Table) {
+            const { billingMode, readCapacity, writeCapacity, maxReadRequestUnits, maxWriteRequestUnits, removalPolicy, } = this.defaultProps;
+            if (removalPolicy) {
+                node.applyRemovalPolicy(removalPolicy);
+            }
+            const cfnTable = node.node.defaultChild;
+            if (!cfnTable)
+                return;
+            if (cfnTable.billingMode === undefined) {
+                cfnTable.billingMode = billingMode;
+            }
+            if (cfnTable.provisionedThroughput === undefined &&
+                this.isProvisionedThroughputConfigured()) {
+                cfnTable.provisionedThroughput = {
+                    readCapacityUnits: readCapacity,
+                    writeCapacityUnits: writeCapacity,
+                };
+            }
+            if (cfnTable.onDemandThroughput === undefined &&
+                this.isOnDemandThroughputConfigured()) {
+                cfnTable.onDemandThroughput = {
+                    maxReadRequestUnits,
+                    maxWriteRequestUnits,
+                };
+            }
+        }
+    }
+}
+exports.DynamoDbDefaultsAspect = DynamoDbDefaultsAspect;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"dynamodb.js","sourceRoot":"","sources":["dynamodb.ts"],"names":[],"mappings":";;;AAAA,6CAA0D;AAC1D,2DAKkC;AAOlC;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAa,sBAAsB;IAGjC;;;;OAIG;IACH,YAAY,MAAc;QACxB,IAAI,CAAC,YAAY,GAAG,IAAI,CAAC,mBAAmB,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC;IAChE,CAAC;IAED;;;;;OAKG;IACK,mBAAmB,CACzB,QAAqC;QAErC,QAAQ,QAAQ,EAAE,CAAC;YACjB,KAAK,OAAO;gBACV,OAAO;oBACL,WAAW,EAAE,0BAAW,CAAC,WAAW;oBACpC,YAAY,EAAE,CAAC;oBACf,aAAa,EAAE,CAAC;oBAChB,aAAa,EAAE,2BAAa,CAAC,OAAO;iBACrC,CAAC;YACJ,KAAK,QAAQ;gBACX,OAAO;oBACL,WAAW,EAAE,0BAAW,CAAC,eAAe;oBACxC,mBAAmB,EAAE,GAAG;oBACxB,oBAAoB,EAAE,GAAG;oBACzB,aAAa,EAAE,2BAAa,CAAC,OAAO;iBACrC,CAAC;YACJ;gBACE,OAAO;oBACL,WAAW,EAAE,0BAAW,CAAC,eAAe;oBACxC,aAAa,EAAE,2BAAa,CAAC,MAAM;iBACpC,CAAC;QACN,CAAC;IACH,CAAC;IAEO,iCAAiC;QACvC,MAAM,EAAE,WAAW,EAAE,YAAY,EAAE,aAAa,EAAE,GAAG,IAAI,CAAC,YAAY,CAAC;QAEvE,OAAO,CACL,WAAW,KAAK,0BAAW,CAAC,WAAW;YACvC,YAAY,KAAK,SAAS;YAC1B,aAAa,KAAK,SAAS,CAC5B,CAAC;IACJ,CAAC;IAEO,8BAA8B;QACpC,MAAM,EAAE,WAAW,EAAE,mBAAmB,EAAE,oBAAoB,EAAE,GAC9D,IAAI,CAAC,YAAY,CAAC;QAEpB,OAAO,CACL,WAAW,KAAK,0BAAW,CAAC,eAAe;YAC3C,mBAAmB,KAAK,SAAS;YACjC,oBAAoB,KAAK,SAAS,CACnC,CAAC;IACJ,CAAC;IAED;;;;;;;OAOG;IACH,KAAK,CAAC,IAAgB;QACpB,IAAI,IAAI,YAAY,oBAAK,EAAE,CAAC;YAC1B,MAAM,EACJ,WAAW,EACX,YAAY,EACZ,aAAa,EACb,mBAAmB,EACnB,oBAAoB,EACpB,aAAa,GACd,GAAG,IAAI,CAAC,YAAY,CAAC;YAEtB,IAAI,aAAa,EAAE,CAAC;gBAClB,IAAI,CAAC,kBAAkB,CAAC,aAAa,CAAC,CAAC;YACzC,CAAC;YAED,MAAM,QAAQ,GAAG,IAAI,CAAC,IAAI,CAAC,YAAwB,CAAC;YACpD,IAAI,CAAC,QAAQ;gBAAE,OAAO;YAEtB,IAAI,QAAQ,CAAC,WAAW,KAAK,SAAS,EAAE,CAAC;gBACvC,QAAQ,CAAC,WAAW,GAAG,WAAW,CAAC;YACrC,CAAC;YAED,IACE,QAAQ,CAAC,qBAAqB,KAAK,SAAS;gBAC5C,IAAI,CAAC,iCAAiC,EAAE,EACxC,CAAC;gBACD,QAAQ,CAAC,qBAAqB,GAAG;oBAC/B,iBAAiB,EAAE,YAAa;oBAChC,kBAAkB,EAAE,aAAc;iBACnC,CAAC;YACJ,CAAC;YAED,IACE,QAAQ,CAAC,kBAAkB,KAAK,SAAS;gBACzC,IAAI,CAAC,8BAA8B,EAAE,EACrC,CAAC;gBACD,QAAQ,CAAC,kBAAkB,GAAG;oBAC5B,mBAAmB;oBACnB,oBAAoB;iBACrB,CAAC;YACJ,CAAC;QACH,CAAC;IACH,CAAC;CACF;AApHD,wDAoHC","sourcesContent":["import { RemovalPolicy, type IAspect } from \"aws-cdk-lib\";\nimport {\n  BillingMode,\n  CfnTable,\n  Table,\n  type TableProps,\n} from \"aws-cdk-lib/aws-dynamodb\";\nimport { IConstruct } from \"constructs\";\n\ninterface Config {\n  duration: \"SHORT\" | \"MEDIUM\" | \"LONG\";\n}\n\n/**\n * Aspect that automatically applies configuration-aware defaults to DynamoDB Tables\n *\n * Visits all constructs in the scope and automatically applies configuration-specific\n * removal policies and point-in-time recovery settings to DynamoDB tables.\n * Different configurations balance between cost optimization and data retention needs.\n *\n * @example\n * ```typescript\n * // Apply configuration-specific defaults to all tables\n * Aspects.of(app).add(new DynamoDbDefaultsAspect({ duration: 'SHORT' }));\n *\n * // Tables automatically inherit configuration defaults\n * new Table(stack, 'MyTable', {\n *   // point-in-time recovery and removal policy applied automatically\n * });\n * ```\n *\n * @see https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_dynamodb.Table.html\n */\nexport class DynamoDbDefaultsAspect implements IAspect {\n  private readonly defaultProps: TableProps;\n\n  /**\n   * Creates a new DynamoDbDefaultsAspect\n   *\n   * @param config - Configuration identifier used to select appropriate defaults.\n   */\n  constructor(config: Config) {\n    this.defaultProps = this.retentionProperties(config.duration);\n  }\n\n  /**\n   * Get duration-specific DynamoDB table properties\n   *\n   * @param duration - The duration to get the table properties for\n   * @returns The table properties for the duration\n   */\n  private retentionProperties(\n    duration: \"SHORT\" | \"MEDIUM\" | \"LONG\"\n  ): TableProps {\n    switch (duration) {\n      case \"SHORT\":\n        return {\n          billingMode: BillingMode.PROVISIONED,\n          readCapacity: 1,\n          writeCapacity: 1,\n          removalPolicy: RemovalPolicy.DESTROY,\n        };\n      case \"MEDIUM\":\n        return {\n          billingMode: BillingMode.PAY_PER_REQUEST,\n          maxReadRequestUnits: 100,\n          maxWriteRequestUnits: 100,\n          removalPolicy: RemovalPolicy.DESTROY,\n        };\n      default:\n        return {\n          billingMode: BillingMode.PAY_PER_REQUEST,\n          removalPolicy: RemovalPolicy.RETAIN,\n        };\n    }\n  }\n\n  private isProvisionedThroughputConfigured() {\n    const { billingMode, readCapacity, writeCapacity } = this.defaultProps;\n\n    return (\n      billingMode === BillingMode.PROVISIONED &&\n      readCapacity !== undefined &&\n      writeCapacity !== undefined\n    );\n  }\n\n  private isOnDemandThroughputConfigured() {\n    const { billingMode, maxReadRequestUnits, maxWriteRequestUnits } =\n      this.defaultProps;\n\n    return (\n      billingMode === BillingMode.PAY_PER_REQUEST &&\n      maxReadRequestUnits !== undefined &&\n      maxWriteRequestUnits !== undefined\n    );\n  }\n\n  /**\n   * Visits a construct and applies configuration-appropriate defaults\n   *\n   * Applies configuration-specific billing mode, throughput, point-in-time recovery,\n   * and removal policies to tables that don't already have these properties explicitly set.\n   *\n   * @param node - The construct to potentially modify\n   */\n  visit(node: IConstruct): void {\n    if (node instanceof Table) {\n      const {\n        billingMode,\n        readCapacity,\n        writeCapacity,\n        maxReadRequestUnits,\n        maxWriteRequestUnits,\n        removalPolicy,\n      } = this.defaultProps;\n\n      if (removalPolicy) {\n        node.applyRemovalPolicy(removalPolicy);\n      }\n\n      const cfnTable = node.node.defaultChild as CfnTable;\n      if (!cfnTable) return;\n\n      if (cfnTable.billingMode === undefined) {\n        cfnTable.billingMode = billingMode;\n      }\n\n      if (\n        cfnTable.provisionedThroughput === undefined &&\n        this.isProvisionedThroughputConfigured()\n      ) {\n        cfnTable.provisionedThroughput = {\n          readCapacityUnits: readCapacity!,\n          writeCapacityUnits: writeCapacity!,\n        };\n      }\n\n      if (\n        cfnTable.onDemandThroughput === undefined &&\n        this.isOnDemandThroughputConfigured()\n      ) {\n        cfnTable.onDemandThroughput = {\n          maxReadRequestUnits,\n          maxWriteRequestUnits,\n        };\n      }\n    }\n  }\n}\n"]}

package/lib/defaults/s3-bucket.d.ts

@@ -0,0 +1,51 @@
+import { type IAspect } from "aws-cdk-lib";
+import { IConstruct } from "constructs";
+interface Config {
+    duration: "SHORT" | "MEDIUM" | "LONG";
+}
+/**
+ * Aspect that automatically applies configuration-aware defaults to S3 Buckets
+ *
+ * Visits all constructs in the scope and automatically applies configuration-specific
+ * lifecycle and removal policies to S3 buckets. Different configurations balance
+ * between cost optimization and data retention needs.
+ *
+ * @example
+ * ```typescript
+ * // Apply configuration-specific defaults to all buckets
+ * Aspects.of(app).add(new S3DefaultsAspect({ autoDelete: true, duration: 'SHORT' }));
+ *
+ * // Buckets automatically inherit configuration defaults
+ * new Bucket(stack, 'MyBucket', {
+ *   // lifecycle and removal policy applied automatically
+ * });
+ * ```
+ *
+ * @see https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_s3.Bucket.html
+ */
+export declare class S3DefaultsAspect implements IAspect {
+    private readonly defaultProps;
+    /**
+     * Creates a new S3DefaultsAspect
+     *
+     * @param config - Configuration identifier used to select appropriate defaults.
+     */
+    constructor(config: Config);
+    /**
+     * Get duration-specific object expiration
+     *
+     * @param duration - The duration to get the expiration for
+     * @returns The expiration Duration, or undefined for LONG retention
+     */
+    private retentionProperties;
+    /**
+     * Visits a construct and applies configuration-appropriate defaults
+     *
+     * Applies a removal policy and lifecycle rules to buckets that don't
+     * already have a lifecycle configuration explicitly set.
+     *
+     * @param node - The construct to potentially modify
+     */
+    visit(node: IConstruct): void;
+}
+export {};

package/lib/defaults/s3-bucket.js

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.S3DefaultsAspect = void 0;
+const aws_cdk_lib_1 = require("aws-cdk-lib");
+const aws_s3_1 = require("aws-cdk-lib/aws-s3");
+/**
+ * Aspect that automatically applies configuration-aware defaults to S3 Buckets
+ *
+ * Visits all constructs in the scope and automatically applies configuration-specific
+ * lifecycle and removal policies to S3 buckets. Different configurations balance
+ * between cost optimization and data retention needs.
+ *
+ * @example
+ * ```typescript
+ * // Apply configuration-specific defaults to all buckets
+ * Aspects.of(app).add(new S3DefaultsAspect({ autoDelete: true, duration: 'SHORT' }));
+ *
+ * // Buckets automatically inherit configuration defaults
+ * new Bucket(stack, 'MyBucket', {
+ *   // lifecycle and removal policy applied automatically
+ * });
+ * ```
+ *
+ * @see https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_s3.Bucket.html
+ */
+class S3DefaultsAspect {
+    /**
+     * Creates a new S3DefaultsAspect
+     *
+     * @param config - Configuration identifier used to select appropriate defaults.
+     */
+    constructor(config) {
+        const props = this.retentionProperties(config.duration);
+        this.defaultProps = { ...props };
+    }
+    /**
+     * Get duration-specific object expiration
+     *
+     * @param duration - The duration to get the expiration for
+     * @returns The expiration Duration, or undefined for LONG retention
+     */
+    retentionProperties(duration) {
+        switch (duration) {
+            case "SHORT":
+                return {
+                    lifecycleRules: [{ expiration: aws_cdk_lib_1.Duration.days(30) }],
+                    removalPolicy: aws_cdk_lib_1.RemovalPolicy.DESTROY,
+                };
+            case "MEDIUM":
+                return {
+                    lifecycleRules: [{ expiration: aws_cdk_lib_1.Duration.days(90) }],
+                    removalPolicy: aws_cdk_lib_1.RemovalPolicy.DESTROY,
+                };
+            default:
+                return {
+                    lifecycleRules: [],
+                    removalPolicy: aws_cdk_lib_1.RemovalPolicy.RETAIN,
+                };
+        }
+    }
+    /**
+     * Visits a construct and applies configuration-appropriate defaults
+     *
+     * Applies a removal policy and lifecycle rules to buckets that don't
+     * already have a lifecycle configuration explicitly set.
+     *
+     * @param node - The construct to potentially modify
+     */
+    visit(node) {
+        if (node instanceof aws_s3_1.Bucket) {
+            const { lifecycleRules, removalPolicy } = this.defaultProps;
+            if (removalPolicy) {
+                node.applyRemovalPolicy(removalPolicy);
+            }
+            if (lifecycleRules === null || lifecycleRules === void 0 ? void 0 : lifecycleRules.length) {
+                const cfnBucket = node.node.defaultChild;
+                if (cfnBucket && cfnBucket.lifecycleConfiguration === undefined) {
+                    lifecycleRules.forEach(rule => node.addLifecycleRule(rule));
+                }
+            }
+        }
+    }
+}
+exports.S3DefaultsAspect = S3DefaultsAspect;
+//# sourceMappingURL=data:application/json;base64,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

package/lib/resource-prefix.d.ts

@@ -0,0 +1,68 @@
+import { IAspect } from "aws-cdk-lib";
+import { IConstruct } from "constructs";
+export interface ResourcePrefixAspectProps {
+    /**
+     * The prefix to apply to all resource names.
+     * e.g. 'myapp-prod' → 'myapp-prod-orders'
+     */
+    prefix: string;
+    /**
+     * Resource types to skip entirely.
+     * e.g. ['AWS::IAM::Role'] to leave IAM role names untouched.
+     * @default []
+     */
+    exclude?: string[];
+}
+/**
+ * CDK Aspect that automatically prefixes physical resource names across AWS resources.
+ *
+ * @remarks
+ * **Critical Implementation Notes:**
+ *
+ * 1. **Stage Synthesis Boundaries**:
+ *    - CDK `Stage` constructs create synthesis boundaries that prevent App-level aspects
+ *      from traversing into them
+ *    - This aspect MUST be applied to each Stage individually, not to the App
+ *    - Example: `Aspects.of(stage).add(new ResourcePrefixAspect({...}))`
+ *
+ * 2. **Property Name Casing**:
+ *    - CloudFormation properties use PascalCase (e.g., `FunctionName`, `BucketName`)
+ *    - Using camelCase (e.g., `functionName`) will cause errors with versioning aspects
+ *    - When using `addPropertyOverride()`, always use the exact CloudFormation property name
+ *
+ * 3. **Aspect Priority with Versioning**:
+ *    - When combining with LambdaAndStepFunctionVersioningAspect, apply this aspect BEFORE versioning
+ *    - Use CDK's priority system: `Aspects.of(stage).add(prefixAspect, { priority: 100 })`
+ *    - Then: `Aspects.of(stage).add(versioningAspect, { priority: 200 })`
+ *    - Lower priority numbers run first
+ *
+ * @example
+ * ```typescript
+ * // Correct usage with staging
+ * const stage = new ApplicationStage(app, 'prod');
+ * Aspects.of(stage).add(new ResourcePrefixAspect({ prefix: 'myapp' }), { priority: 100 });
+ * Aspects.of(stage).add(new LambdaAndStepFunctionVersioningAspect(), { priority: 200 });
+ * ```
+ */
+export declare class ResourcePrefixAspect implements IAspect {
+    private readonly prefix;
+    private readonly exclude;
+    constructor(props: ResourcePrefixAspectProps);
+    visit(node: IConstruct): void;
+    private isAlreadyPrefixed;
+    private deriveNameFromLogicalId;
+    /**
+     * Builds the prefixed name, handling special cases for specific resource types.
+     *
+     * @param baseName - The base resource name (without prefix)
+     * @param cfnResourceType - The CloudFormation resource type
+     * @param cfnProperties - The CloudFormation resource properties
+     * @returns The final prefixed name with any special case handling applied
+     */
+    private buildPrefixedName;
+    /**
+     * Validates resource-specific naming requirements that AWS enforces.
+     * Throws synthesis errors for violations.
+     */
+    private validateResourceName;
+}

package/lib/resource-prefix.js

@@ -0,0 +1,187 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ResourcePrefixAspect = void 0;
+const aws_cdk_lib_1 = require("aws-cdk-lib");
+/**
+ * Maps CloudFormation resource types to their name property and AWS length limits.
+ * Sources: https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-template-resource-type-ref.html
+ */
+const RESOURCE_CONFIG = {
+    // Compute
+    "AWS::Lambda::Function": { cfnName: "FunctionName", maxLength: 64 },
+    // Storage
+    "AWS::S3::Bucket": { cfnName: "BucketName", maxLength: 63 },
+    "AWS::DynamoDB::Table": { cfnName: "TableName", maxLength: 255 },
+    "AWS::DynamoDB::GlobalTable": { cfnName: "TableName", maxLength: 255 },
+    // Messaging
+    "AWS::SQS::Queue": { cfnName: "QueueName", maxLength: 80 },
+    "AWS::SNS::Topic": { cfnName: "TopicName", maxLength: 256 },
+    // Eventing & Orchestration
+    "AWS::Events::EventBus": { cfnName: "Name", maxLength: 256 },
+    "AWS::Events::Rule": { cfnName: "Name", maxLength: 64 },
+    "AWS::Events::Connection": { cfnName: "Name", maxLength: 64 },
+    "AWS::Pipes::Pipe": { cfnName: "Name", maxLength: 64 },
+    "AWS::StepFunctions::StateMachine": {
+        cfnName: "StateMachineName",
+        maxLength: 80,
+    },
+    "AWS::StepFunctions::Activity": { cfnName: "Name", maxLength: 80 },
+    "AWS::Scheduler::Schedule": { cfnName: "Name", maxLength: 64 },
+    "AWS::Scheduler::ScheduleGroup": { cfnName: "Name", maxLength: 64 },
+    // API
+    "AWS::ApiGateway::RestApi": { cfnName: "Name", maxLength: 128 },
+    "AWS::ApiGateway::UsagePlan": { cfnName: "UsagePlanName", maxLength: 128 },
+    "AWS::ApiGateway::ApiKey": { cfnName: "Name", maxLength: 128 },
+    "AWS::ApiGatewayV2::Api": { cfnName: "Name", maxLength: 128 },
+    "AWS::ApiGatewayV2::Authorizer": { cfnName: "Name", maxLength: 128 },
+    // Secrets & Config
+    "AWS::SecretsManager::Secret": { cfnName: "Name", maxLength: 512 },
+    "AWS::SSM::Parameter": { cfnName: "Name", maxLength: 2048 },
+    "AWS::AppConfig::Application": { cfnName: "Name", maxLength: 64 },
+    "AWS::AppConfig::Environment": { cfnName: "Name", maxLength: 64 },
+    // Notifications
+    "AWS::Notifications::NotificationConfiguration": {
+        cfnName: "Name",
+        maxLength: 64,
+    },
+    // Observability
+    "AWS::Logs::LogGroup": { cfnName: "LogGroupName", maxLength: 512 },
+    "AWS::CloudWatch::Alarm": { cfnName: "AlarmName", maxLength: 255 },
+    // IAM
+    "AWS::IAM::Role": { cfnName: "RoleName", maxLength: 64 },
+};
+/**
+ * CDK Aspect that automatically prefixes physical resource names across AWS resources.
+ *
+ * @remarks
+ * **Critical Implementation Notes:**
+ *
+ * 1. **Stage Synthesis Boundaries**:
+ *    - CDK `Stage` constructs create synthesis boundaries that prevent App-level aspects
+ *      from traversing into them
+ *    - This aspect MUST be applied to each Stage individually, not to the App
+ *    - Example: `Aspects.of(stage).add(new ResourcePrefixAspect({...}))`
+ *
+ * 2. **Property Name Casing**:
+ *    - CloudFormation properties use PascalCase (e.g., `FunctionName`, `BucketName`)
+ *    - Using camelCase (e.g., `functionName`) will cause errors with versioning aspects
+ *    - When using `addPropertyOverride()`, always use the exact CloudFormation property name
+ *
+ * 3. **Aspect Priority with Versioning**:
+ *    - When combining with LambdaAndStepFunctionVersioningAspect, apply this aspect BEFORE versioning
+ *    - Use CDK's priority system: `Aspects.of(stage).add(prefixAspect, { priority: 100 })`
+ *    - Then: `Aspects.of(stage).add(versioningAspect, { priority: 200 })`
+ *    - Lower priority numbers run first
+ *
+ * @example
+ * ```typescript
+ * // Correct usage with staging
+ * const stage = new ApplicationStage(app, 'prod');
+ * Aspects.of(stage).add(new ResourcePrefixAspect({ prefix: 'myapp' }), { priority: 100 });
+ * Aspects.of(stage).add(new LambdaAndStepFunctionVersioningAspect(), { priority: 200 });
+ * ```
+ */
+class ResourcePrefixAspect {
+    constructor(props) {
+        var _a;
+        if (!props.prefix || !/^[a-z0-9-]+$/.test(props.prefix))
+            throw new Error(`ResourcePrefixAspect: prefix must contain only lowercase alphanumeric characters and hyphens, got "${props.prefix}"`);
+        this.prefix = props.prefix;
+        this.exclude = new Set((_a = props.exclude) !== null && _a !== void 0 ? _a : []);
+    }
+    visit(node) {
+        var _a, _b;
+        if (!(node instanceof aws_cdk_lib_1.CfnResource))
+            return;
+        const resourceType = node.cfnResourceType;
+        const config = RESOURCE_CONFIG[resourceType];
+        if (!config || this.exclude.has(resourceType)) {
+            return;
+        }
+        const { cfnName, maxLength } = config;
+        const cfnProperties = (_b = (_a = node._cfnProperties) !== null && _a !== void 0 ? _a : node.cfnProperties) !== null && _b !== void 0 ? _b : {};
+        // Get any explicitly set name, or derive one from the logical ID
+        const existingName = typeof cfnProperties[cfnName] === "string"
+            ? cfnProperties[cfnName]
+            : undefined;
+        const baseName = existingName !== null && existingName !== void 0 ? existingName : this.deriveNameFromLogicalId(node);
+        if (this.isAlreadyPrefixed(baseName)) {
+            return;
+        }
+        const finalName = this.buildPrefixedName(baseName, resourceType, cfnProperties);
+        const hasError = this.validateResourceName(finalName, resourceType, maxLength, node);
+        if (hasError)
+            return;
+        node.addPropertyOverride(cfnName, finalName);
+    }
+    isAlreadyPrefixed(name) {
+        return (name.startsWith(`${this.prefix}-`) || name.startsWith(`/${this.prefix}/`));
+    }
+    deriveNameFromLogicalId(node) {
+        const logicalId = aws_cdk_lib_1.Stack.of(node).getLogicalId(node);
+        return logicalId
+            .replace(/[^a-zA-Z0-9]+/g, "-") // non-alphanumeric → dash
+            .replace(/^-+|-+$/g, ""); // trim leading/trailing dashes
+    }
+    /**
+     * Builds the prefixed name, handling special cases for specific resource types.
+     *
+     * @param baseName - The base resource name (without prefix)
+     * @param cfnResourceType - The CloudFormation resource type
+     * @param cfnProperties - The CloudFormation resource properties
+     * @returns The final prefixed name with any special case handling applied
+     */
+    buildPrefixedName(baseName, cfnResourceType, cfnProperties) {
+        // Special case: FIFO queues must end with .fifo suffix
+        if (cfnResourceType === "AWS::SQS::Queue" &&
+            cfnProperties.fifoQueue === true &&
+            !baseName.endsWith(".fifo")) {
+            return `${this.prefix}-${baseName}.fifo`;
+        }
+        // Special case: FIFO topics must end with .fifo suffix
+        if (cfnResourceType === "AWS::SNS::Topic" &&
+            cfnProperties.fifoTopic === true &&
+            !baseName.endsWith(".fifo")) {
+            return `${this.prefix}-${baseName}.fifo`;
+        }
+        // Special case: SSM parameter names use path-style prefix
+        if (cfnResourceType === "AWS::SSM::Parameter") {
+            return `/${this.prefix}/${baseName}`;
+        }
+        // Special case: S3 bucket name be lowercase only
+        if (cfnResourceType === "AWS::S3::Bucket") {
+            return `${this.prefix}-${baseName}`.toLowerCase();
+        }
+        // Default: simple prefix
+        return `${this.prefix}-${baseName}`;
+    }
+    /**
+     * Validates resource-specific naming requirements that AWS enforces.
+     * Throws synthesis errors for violations.
+     */
+    validateResourceName(name, cfnResourceType, maxLength, 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. ` +
+                    `Bucket names must be lowercase only.`);
+                hasError = true;
+            }
+            if (name.includes("_")) {
+                aws_cdk_lib_1.Annotations.of(node).addError(`[ResourcePrefixAspect] S3 bucket name "${name}" contains underscores. ` +
+                    `Bucket names cannot contain underscores. Use hyphens instead.`);
+                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"]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aligent/cdk-aspects",
-  "version": "0.3.2",
+  "version": "0.5.0",
   "description": "Collection of CDK Asppects",
   "main": "index.js",
   "types": "index.d.ts",