Merge pull request #435 from getlift/storage-lifecycle

Add support for S3 lifecycle rules on the `storage` construct

Author: mnapoli

docs/storage.md

@@ -91,6 +91,28 @@ constructs:
         encryption: kms
 ```
 
+### Lifecycle rules
+
+You can configure custom [S3 lifecycle rules](https://docs.aws.amazon.com/AmazonS3/latest/userguide/object-lifecycle-mgmt.html) to automatically delete or transition objects:
+
+```yaml
+constructs:
+    avatars:
+        type: storage
+        lifecycleRules:
+            - prefix: tmp/
+              expirationInDays: 1
+            - prefix: cache/
+              expirationInDays: 7
+```
+
+The configuration maps directly to [CloudFormation LifecycleConfiguration Rules](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-s3-bucket-lifecycleconfig-rule.html) with the following conveniences:
+
+- `Status: Enabled` is added by default (can be overridden)
+- Property names can be written in camelCase (e.g. `expirationInDays`) or PascalCase (e.g. `ExpirationInDays`)
+
+These rules are added to the default lifecycle rules that Lift adds (intelligent tiering and old version cleanup).
+
 ## Extensions
 
 You can specify an `extensions` property on the storage construct to extend the underlying CloudFormation resources. In the exemple below, the S3 Bucket CloudFormation resource generated by the `avatars` storage construct will be extended with the new `AccessControl: PublicRead` CloudFormation property.

src/constructs/aws/Storage.ts

@@ -1,7 +1,7 @@
 import type { CfnBucket } from "aws-cdk-lib/aws-s3";
-import { BlockPublicAccess, Bucket, BucketEncryption, StorageClass } from "aws-cdk-lib/aws-s3";
+import { BlockPublicAccess, Bucket, BucketEncryption } from "aws-cdk-lib/aws-s3";
 import type { Construct as CdkConstruct } from "constructs";
-import { CfnOutput, Duration, Fn, Stack } from "aws-cdk-lib";
+import { CfnOutput, Fn, Stack } from "aws-cdk-lib";
 import type { CfnResource } from "aws-cdk-lib";
 import type { FromSchema } from "json-schema-to-ts";
 import type { AwsProvider } from "@lift/providers";
@@ -16,15 +16,42 @@ const STORAGE_DEFINITION = {
         encryption: {
             anyOf: [{ const: "s3" }, { const: "kms" }],
         },
+        lifecycleRules: {
+            type: "array",
+            items: { type: "object" },
+        },
     },
     additionalProperties: false,
 } as const;
 const STORAGE_DEFAULTS: Required<FromSchema<typeof STORAGE_DEFINITION>> = {
     type: "storage",
     archive: 45,
     encryption: "s3",
+    lifecycleRules: [],
 };
 
+function capitalizeFirstLetter(str: string): string {
+    return str.charAt(0).toUpperCase() + str.slice(1);
+}
+
+function capitalizeKeys(obj: Record<string, unknown>): Record<string, unknown> {
+    const result: Record<string, unknown> = {};
+    for (const [key, value] of Object.entries(obj)) {
+        const capitalizedKey = capitalizeFirstLetter(key);
+        if (Array.isArray(value)) {
+            result[capitalizedKey] = value.map((item: unknown) =>
+                typeof item === "object" && item !== null ? capitalizeKeys(item as Record<string, unknown>) : item
+            );
+        } else if (typeof value === "object" && value !== null) {
+            result[capitalizedKey] = capitalizeKeys(value as Record<string, unknown>);
+        } else {
+            result[capitalizedKey] = value;
+        }
+    }
+
+    return result;
+}
+
 type Configuration = FromSchema<typeof STORAGE_DEFINITION>;
 
 export class Storage extends AwsConstruct {
@@ -50,19 +77,40 @@ export class Storage extends AwsConstruct {
             versioned: true,
             blockPublicAccess: BlockPublicAccess.BLOCK_ALL,
             enforceSSL: true,
-            lifecycleRules: [
-                {
-                    transitions: [
-                        {
-                            storageClass: StorageClass.INTELLIGENT_TIERING,
-                            transitionAfter: Duration.days(0),
-                        },
-                    ],
-                },
-                {
-                    noncurrentVersionExpiration: Duration.days(30),
+        });
+
+        // Default lifecycle rules (always applied)
+        const defaultRules = [
+            {
+                Status: "Enabled",
+                Transitions: [
+                    {
+                        StorageClass: "INTELLIGENT_TIERING",
+                        TransitionInDays: 0,
+                    },
+                ],
+            },
+            {
+                Status: "Enabled",
+                NoncurrentVersionExpiration: {
+                    NoncurrentDays: 30,
                 },
-            ],
+            },
+        ];
+
+        // Transform user rules: capitalize keys and add Status: Enabled by default
+        const userRules = resolvedConfiguration.lifecycleRules.map((rule) => {
+            const capitalizedRule = capitalizeKeys(rule as Record<string, unknown>);
+            if (!("Status" in capitalizedRule)) {
+                capitalizedRule.Status = "Enabled";
+            }
+
+            return capitalizedRule;
+        });
+
+        const cfnBucket = this.bucket.node.defaultChild as CfnBucket;
+        cfnBucket.addPropertyOverride("LifecycleConfiguration", {
+            Rules: [...defaultRules, ...userRules],
         });
 
         this.bucketNameOutput = new CfnOutput(this, "BucketName", {

test/fixtures/storage/serverless.yml

@@ -32,3 +32,11 @@ constructs:
                                   - HEAD
                                   - PUT
                                   - POST
+    withLifecycleRules:
+        type: storage
+        lifecycleRules:
+            - prefix: tmp/
+              expirationInDays: 1
+            - Prefix: cache/
+              ExpirationInDays: 7
+              Status: Disabled

test/unit/storage.test.ts

@@ -76,4 +76,32 @@ describe("storage", () => {
             },
         });
     });
+
+    it("supports custom lifecycleRules with auto-capitalization and default Status", () => {
+        const lifecycleConfig = cfTemplate.Resources[computeLogicalId("withLifecycleRules", "Bucket")].Properties
+            .LifecycleConfiguration as { Rules: unknown[] };
+        expect(lifecycleConfig.Rules).toEqual([
+            // Default rules
+            {
+                Status: "Enabled",
+                Transitions: [{ StorageClass: "INTELLIGENT_TIERING", TransitionInDays: 0 }],
+            },
+            {
+                Status: "Enabled",
+                NoncurrentVersionExpiration: { NoncurrentDays: 30 },
+            },
+            // User rules (lowercase keys capitalized, Status: Enabled added by default)
+            {
+                Prefix: "tmp/",
+                ExpirationInDays: 1,
+                Status: "Enabled",
+            },
+            // User rule with already-capitalized keys and custom Status
+            {
+                Prefix: "cache/",
+                ExpirationInDays: 7,
+                Status: "Disabled",
+            },
+        ]);
+    });
 });