@aligent/cdk-aspects 0.2.0 → 0.3.0

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # @aligent/cdk-aspects
 
+## 0.3.0
+
+### Minor Changes
+
+- [#1582](https://github.com/aligent/cdk-constructs/pull/1582) [`e069f79`](https://github.com/aligent/cdk-constructs/commit/e069f794bdbb003510ffb769504bc776839c7500) Thanks [@kai-nguyen-aligent](https://github.com/kai-nguyen-aligent)! - Migrate new Microservices default aspects (log-group, nodejs-function, and step-functions); Re-organies aspects depends on their functionality.
+
 ## 0.2.0
 
 ### Minor Changes

package/README.md

@@ -1,21 +1,99 @@
 # Aligent CDK Aspects
 
+![TypeScript version](https://img.shields.io/github/package-json/dependency-version/aligent/cdk-constructs/dev/typescript?filename=packages/cdk-aspects/package.json&color=red) ![AWS CDK version](https://img.shields.io/github/package-json/dependency-version/aligent/cdk-constructs/dev/aws-cdk?filename=packages/cdk-aspects/package.json) ![NPM version](https://img.shields.io/npm/v/%40aligent%2Fcdk-aspects?color=green)
+
 This package provides a collection of CDK aspects that can be applied to your AWS CDK stacks to enforce best practices and automate common configurations.
 
 ## Defaults
 
-### Microservice Checks
+A collection of aspects that automatically apply best-practice defaults to AWS resources in your CDK stacks.
 
-A set of rules that validate your infrastructure against recommended practices using the cdk-nag library.
+### Log Group Defaults
+
+Automatically applies configuration-aware defaults to CloudWatch Log Groups, balancing between cost optimization and data retention needs.
+
+#### Features
+
+- Automatically configures retention periods based on duration profile
+- Applies appropriate removal policies
+- Duration profiles:
+  - **SHORT**: 1 week retention, destroy on stack deletion
+  - **MEDIUM**: 6 months retention, destroy on stack deletion
+  - **LONG**: 2 years retention, retain on stack deletion
+
+#### Usage
+
+```typescript
+import { Aspects } from "aws-cdk-lib";
+import { LogGroupDefaultsAspect } from "@aligent/cdk-aspects";
+
+const app = new App();
+Aspects.of(app).add(new LogGroupDefaultsAspect({ duration: "SHORT" }));
+```
+
+### Node.js Function Defaults
+
+Automatically applies configuration-aware defaults to Node.js Lambda functions for consistent runtime configuration and observability.
+
+#### Features
+
+- Configures Node.js runtime version
+- Enables X-Ray tracing by default
+- Optionally enables source maps for better error stack traces (default: enabled)
+- Configures default memory size (default: 256 MB)
+- Configures default timeout (default: 3 seconds)
+
+#### Usage
+
+```typescript
+import { Aspects } from "aws-cdk-lib";
+import { Runtime } from "aws-cdk-lib/aws-lambda";
+import { NodeJsFunctionDefaultsAspect } from "@aligent/cdk-aspects";
+
+const app = new App();
+Aspects.of(app).add(
+  new NodeJsFunctionDefaultsAspect({
+    runtime: Runtime.NODEJS_24_X,
+    sourceMap: true, // default: true
+    memorySize: 256, // default: 256
+    timeout: 3, // default: 3
+  })
+);
+```
+
+### Step Functions Defaults
+
+Automatically applies tracing and logging settings to AWS Step Functions state machines for enhanced observability.
 
 #### Features
 
+- Enables X-Ray tracing for all state machines
+- Automatically creates log groups for EXPRESS state machines
+- Configures comprehensive logging with full execution data capture
+
+#### Usage
+
+```typescript
+import { Aspects } from "aws-cdk-lib";
+import { StepFunctionsDefaultsAspect } from "@aligent/cdk-aspects";
+
+const app = new App();
+Aspects.of(app).add(new StepFunctionsDefaultsAspect());
+```
+
+
+## Microservice Checks
+
+A set of rules that validate your infrastructure against recommended practices using the cdk-nag library.
+
+### Features
+
 - Validates Lambda function memory configuration
 - Validates Lambda function timeout configuration
 - Validates Lambda function tracing configuration
 - Validates CloudWatch Log Group retention policy
 
-#### Usage
+### Usage
 
 ```typescript
 import { Aspects } from "aws-cdk-lib";
@@ -27,17 +105,17 @@ const stack = new Stack(app, "MyStack");
 Aspects.of(stack).add(new MicroserviceChecks());
 ```
 
-### Version Functions
+## Version Functions
 
 An aspect that automatically adds versioning and aliases to Lambda functions and Step Functions.
 
-#### Features
+### Features
 
 - Automatically creates function aliases for Lambda functions
 - Creates versions and aliases for Step Functions with 100% traffic routing
 - Supports custom alias names
 
-#### Usage
+### Usage
 
 ```typescript
 import { Aspects } from "aws-cdk-lib";

package/index.d.ts

@@ -1,3 +1,5 @@
-import { MicroserviceChecks } from "./lib/defaults/microservice-checks/microservice-checks";
-import { VersionFunctionsAspect } from "./lib/defaults/version-functions/version-functions";
-export { MicroserviceChecks, VersionFunctionsAspect };
+export * from "./lib/defaults/log-group";
+export * from "./lib/defaults/nodejs-function";
+export * from "./lib/defaults/step-functions";
+export * from "./lib/lambda-sfn-versioning";
+export * from "./lib/microservice-checks";

package/index.js

@@ -1,8 +1,22 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+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 });
-exports.VersionFunctionsAspect = exports.MicroserviceChecks = void 0;
-const microservice_checks_1 = require("./lib/defaults/microservice-checks/microservice-checks");
-Object.defineProperty(exports, "MicroserviceChecks", { enumerable: true, get: function () { return microservice_checks_1.MicroserviceChecks; } });
-const version_functions_1 = require("./lib/defaults/version-functions/version-functions");
-Object.defineProperty(exports, "VersionFunctionsAspect", { enumerable: true, get: function () { return version_functions_1.VersionFunctionsAspect; } });
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyJpbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7QUFBQSxnR0FBNEY7QUFHbkYsbUdBSEEsd0NBQWtCLE9BR0E7QUFGM0IsMEZBQTRGO0FBRS9ELHVHQUZwQiwwQ0FBc0IsT0FFb0IiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBNaWNyb3NlcnZpY2VDaGVja3MgfSBmcm9tIFwiLi9saWIvZGVmYXVsdHMvbWljcm9zZXJ2aWNlLWNoZWNrcy9taWNyb3NlcnZpY2UtY2hlY2tzXCI7XG5pbXBvcnQgeyBWZXJzaW9uRnVuY3Rpb25zQXNwZWN0IH0gZnJvbSBcIi4vbGliL2RlZmF1bHRzL3ZlcnNpb24tZnVuY3Rpb25zL3ZlcnNpb24tZnVuY3Rpb25zXCI7XG5cbmV4cG9ydCB7IE1pY3Jvc2VydmljZUNoZWNrcywgVmVyc2lvbkZ1bmN0aW9uc0FzcGVjdCB9O1xuIl19
+__exportStar(require("./lib/defaults/log-group"), exports);
+__exportStar(require("./lib/defaults/nodejs-function"), 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==

package/lib/defaults/log-group.d.ts

@@ -0,0 +1,50 @@
+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 CloudWatch Log Groups
+ *
+ * Visits all constructs in the scope and automatically applies configuration-specific to log groups.
+ * Different configurations balance between cost optimization and data retention needs.
+ *
+ * @example
+ * ```typescript
+ * // Apply configuration-specific defaults to all log groups
+ * Aspects.of(app).add(new LogGroupDefaultsAspect({ duration: 'SHORT' }));
+ *
+ * // Log groups automatically inherit configuration defaults
+ * new LogGroup(stack, 'MyLogGroup', {
+ *   // retention and removal policy applied automatically
+ * });
+ * ```
+ *
+ * @see https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_logs.LogGroup.html
+ */
+export declare class LogGroupDefaultsAspect implements IAspect {
+    private readonly defaultProps;
+    /**
+     * Creates a new LogGroupDefaultsAspect
+     *
+     * @param config - Configuration identifier used to select appropriate defaults.
+     */
+    constructor(config: Config);
+    /**
+     * Get duration-specific log group properties
+     *
+     * @param duration - The duration to get the log group properties for
+     * @returns The log group properties for the duration
+     */
+    private retentionProperties;
+    /**
+     * Visits a construct and applies configuration-appropriate defaults
+     *
+     * Applies configuration-specific retention and removal policies to log groups
+     * that don't already have these properties explicitly set.
+     *
+     * @param node - The construct to potentially modify
+     */
+    visit(node: IConstruct): void;
+}
+export {};

package/lib/defaults/log-group.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LogGroupDefaultsAspect = void 0;
+const aws_cdk_lib_1 = require("aws-cdk-lib");
+const aws_logs_1 = require("aws-cdk-lib/aws-logs");
+/**
+ * Aspect that automatically applies configuration-aware defaults to CloudWatch Log Groups
+ *
+ * Visits all constructs in the scope and automatically applies configuration-specific to log groups.
+ * Different configurations balance between cost optimization and data retention needs.
+ *
+ * @example
+ * ```typescript
+ * // Apply configuration-specific defaults to all log groups
+ * Aspects.of(app).add(new LogGroupDefaultsAspect({ duration: 'SHORT' }));
+ *
+ * // Log groups automatically inherit configuration defaults
+ * new LogGroup(stack, 'MyLogGroup', {
+ *   // retention and removal policy applied automatically
+ * });
+ * ```
+ *
+ * @see https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_logs.LogGroup.html
+ */
+class LogGroupDefaultsAspect {
+    /**
+     * Creates a new LogGroupDefaultsAspect
+     *
+     * @param config - Configuration identifier used to select appropriate defaults.
+     */
+    constructor(config) {
+        const props = this.retentionProperties(config.duration);
+        this.defaultProps = { ...props };
+    }
+    /**
+     * Get duration-specific log group properties
+     *
+     * @param duration - The duration to get the log group properties for
+     * @returns The log group properties for the duration
+     */
+    retentionProperties(duration) {
+        switch (duration) {
+            case "SHORT":
+                return {
+                    retention: aws_logs_1.RetentionDays.ONE_WEEK,
+                    removalPolicy: aws_cdk_lib_1.RemovalPolicy.DESTROY,
+                };
+            case "MEDIUM":
+                return {
+                    retention: aws_logs_1.RetentionDays.SIX_MONTHS,
+                    removalPolicy: aws_cdk_lib_1.RemovalPolicy.DESTROY,
+                };
+            default:
+                return {
+                    retention: aws_logs_1.RetentionDays.TWO_YEARS,
+                    removalPolicy: aws_cdk_lib_1.RemovalPolicy.RETAIN,
+                };
+        }
+    }
+    /**
+     * Visits a construct and applies configuration-appropriate defaults
+     *
+     * Applies configuration-specific retention and removal policies to log groups
+     * that don't already have these properties explicitly set.
+     *
+     * @param node - The construct to potentially modify
+     */
+    visit(node) {
+        if (node instanceof aws_logs_1.LogGroup) {
+            if (this.defaultProps.removalPolicy) {
+                node.applyRemovalPolicy(this.defaultProps.removalPolicy);
+            }
+            if (this.defaultProps.retention) {
+                const cfnLogGroup = node.node.defaultChild;
+                if (cfnLogGroup && cfnLogGroup.retentionInDays === undefined) {
+                    cfnLogGroup.retentionInDays = this.defaultProps.retention;
+                }
+            }
+        }
+    }
+}
+exports.LogGroupDefaultsAspect = LogGroupDefaultsAspect;
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,52 @@
+import { type IAspect } from "aws-cdk-lib";
+import { Runtime } from "aws-cdk-lib/aws-lambda";
+import { IConstruct } from "constructs";
+interface Config {
+    runtime: Runtime;
+    sourceMap?: boolean;
+    memorySize?: number;
+    timeout?: number;
+}
+/**
+ * Aspect that automatically applies configuration-aware defaults to Node.js Lambda functions
+ *
+ * Visits all constructs in the scope and automatically applies configuration-specific runtime, tracing, and environment settings to Node.js Lambda functions.
+ * Different configurations can optimize for different priorities such as build speed, bundle size, or debugging capabilities.
+ *
+ * @example
+ * ```typescript
+ * // Apply configuration-specific defaults to all Node.js functions
+ * Aspects.of(app).add(new NodeJsFunctionDefaultsAspect({
+ *   runtime: Runtime.NODEJS_24_X,
+ *   sourceMap: true,
+ * }));
+ *
+ * // Functions automatically inherit configuration defaults
+ * new NodejsFunction(stack, 'MyFunction', {
+ *   code: Code.fromAsset('src/lambda'),
+ *   handler: 'index.handler',
+ *   // runtime, tracing, and source map support applied automatically
+ * });
+ * ```
+ *
+ * @see https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_lambda_nodejs.NodejsFunction.html
+ */
+export declare class NodeJsFunctionDefaultsAspect implements IAspect {
+    private readonly config;
+    /**
+     * Creates a new NodeJsFunctionDefaultsAspect
+     *
+     * @param config - Configuration identifier used to select appropriate defaults.
+     */
+    constructor(config: Config);
+    /**
+     * Visits a construct and applies runtime and tracing settings if it's a NodejsFunction
+     *
+     * Applies configuration-specific runtime, tracing, and environment settings to Node.js
+     * Lambda functions that don't already have these properties explicitly set.
+     *
+     * @param node - The construct to potentially modify
+     */
+    visit(node: IConstruct): void;
+}
+export {};

package/lib/defaults/nodejs-function.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NodeJsFunctionDefaultsAspect = void 0;
+const aws_lambda_1 = require("aws-cdk-lib/aws-lambda");
+const aws_lambda_nodejs_1 = require("aws-cdk-lib/aws-lambda-nodejs");
+/**
+ * Aspect that automatically applies configuration-aware defaults to Node.js Lambda functions
+ *
+ * Visits all constructs in the scope and automatically applies configuration-specific runtime, tracing, and environment settings to Node.js Lambda functions.
+ * Different configurations can optimize for different priorities such as build speed, bundle size, or debugging capabilities.
+ *
+ * @example
+ * ```typescript
+ * // Apply configuration-specific defaults to all Node.js functions
+ * Aspects.of(app).add(new NodeJsFunctionDefaultsAspect({
+ *   runtime: Runtime.NODEJS_24_X,
+ *   sourceMap: true,
+ * }));
+ *
+ * // Functions automatically inherit configuration defaults
+ * new NodejsFunction(stack, 'MyFunction', {
+ *   code: Code.fromAsset('src/lambda'),
+ *   handler: 'index.handler',
+ *   // runtime, tracing, and source map support applied automatically
+ * });
+ * ```
+ *
+ * @see https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_lambda_nodejs.NodejsFunction.html
+ */
+class NodeJsFunctionDefaultsAspect {
+    /**
+     * Creates a new NodeJsFunctionDefaultsAspect
+     *
+     * @param config - Configuration identifier used to select appropriate defaults.
+     */
+    constructor(config) {
+        var _a, _b, _c;
+        this.config = {
+            ...config,
+            sourceMap: (_a = config.sourceMap) !== null && _a !== void 0 ? _a : true,
+            memorySize: (_b = config.memorySize) !== null && _b !== void 0 ? _b : 256,
+            timeout: (_c = config.timeout) !== null && _c !== void 0 ? _c : 3,
+        };
+    }
+    /**
+     * Visits a construct and applies runtime and tracing settings if it's a NodejsFunction
+     *
+     * Applies configuration-specific runtime, tracing, and environment settings to Node.js
+     * Lambda functions that don't already have these properties explicitly set.
+     *
+     * @param node - The construct to potentially modify
+     */
+    visit(node) {
+        if (node instanceof aws_lambda_nodejs_1.NodejsFunction) {
+            const cfnFunction = node.node.defaultChild;
+            if (cfnFunction) {
+                cfnFunction.runtime = this.config.runtime.name;
+            }
+            if (cfnFunction && cfnFunction.tracingConfig === undefined) {
+                cfnFunction.tracingConfig = { mode: aws_lambda_1.Tracing.ACTIVE };
+            }
+            if (cfnFunction && cfnFunction.memorySize === undefined) {
+                cfnFunction.memorySize = this.config.memorySize;
+            }
+            if (cfnFunction && cfnFunction.timeout === undefined) {
+                cfnFunction.timeout = this.config.timeout;
+            }
+            if (this.config.sourceMap) {
+                node.addEnvironment("NODE_OPTIONS", "--enable-source-maps");
+            }
+        }
+    }
+}
+exports.NodeJsFunctionDefaultsAspect = NodeJsFunctionDefaultsAspect;
+//# sourceMappingURL=data:application/json;base64,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

package/lib/defaults/step-functions.d.ts

@@ -0,0 +1,36 @@
+import { type IAspect } from "aws-cdk-lib";
+import { IConstruct } from "constructs";
+/**
+ * Aspect that automatically applies tracing and logging settings to Step Functions
+ *
+ * Visits all constructs in the scope and automatically applies X-Ray tracing to all
+ * state machines. For EXPRESS state machines, automatically creates log groups and
+ * configures comprehensive logging for enhanced observability.
+ *
+ * @example
+ * ```typescript
+ * // Apply configuration-specific defaults to all Step Functions
+ * Aspects.of(app).add(new StepFunctionDefaultsAspect());
+ *
+ * // Step Functions automatically inherit defaults
+ * new StateMachine(stack, 'MyWorkflow', {
+ *   stateMachineType: StateMachineType.EXPRESS,
+ *   definitionBody: DefinitionBody.fromFile('workflow.asl.yaml'),
+ *   // tracing enabled and logging configured automatically for EXPRESS
+ * });
+ * ```
+ *
+ * @see https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_stepfunctions.StateMachine.html
+ */
+export declare class StepFunctionsDefaultsAspect implements IAspect {
+    /**
+     * Visits a construct and applies tracing and logging settings if it's a StateMachine
+     *
+     * Enables X-Ray tracing for all state machines. For EXPRESS state machines that don't
+     * already have logging configured, automatically creates log groups and configures
+     * comprehensive logging with full execution data capture.
+     *
+     * @param node - The construct to potentially modify
+     */
+    visit(node: IConstruct): void;
+}

package/lib/defaults/step-functions.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StepFunctionsDefaultsAspect = void 0;
+const aws_logs_1 = require("aws-cdk-lib/aws-logs");
+const aws_stepfunctions_1 = require("aws-cdk-lib/aws-stepfunctions");
+/**
+ * Aspect that automatically applies tracing and logging settings to Step Functions
+ *
+ * Visits all constructs in the scope and automatically applies X-Ray tracing to all
+ * state machines. For EXPRESS state machines, automatically creates log groups and
+ * configures comprehensive logging for enhanced observability.
+ *
+ * @example
+ * ```typescript
+ * // Apply configuration-specific defaults to all Step Functions
+ * Aspects.of(app).add(new StepFunctionDefaultsAspect());
+ *
+ * // Step Functions automatically inherit defaults
+ * new StateMachine(stack, 'MyWorkflow', {
+ *   stateMachineType: StateMachineType.EXPRESS,
+ *   definitionBody: DefinitionBody.fromFile('workflow.asl.yaml'),
+ *   // tracing enabled and logging configured automatically for EXPRESS
+ * });
+ * ```
+ *
+ * @see https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_stepfunctions.StateMachine.html
+ */
+class StepFunctionsDefaultsAspect {
+    /**
+     * Visits a construct and applies tracing and logging settings if it's a StateMachine
+     *
+     * Enables X-Ray tracing for all state machines. For EXPRESS state machines that don't
+     * already have logging configured, automatically creates log groups and configures
+     * comprehensive logging with full execution data capture.
+     *
+     * @param node - The construct to potentially modify
+     */
+    visit(node) {
+        if (node instanceof aws_stepfunctions_1.StateMachine) {
+            const cfnStateMachine = node.node.defaultChild;
+            if (cfnStateMachine) {
+                // Apply tracing if not already set
+                if (cfnStateMachine.tracingConfiguration === undefined) {
+                    cfnStateMachine.tracingConfiguration = {
+                        enabled: true,
+                    };
+                }
+                // 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,
+                                },
+                            },
+                        ],
+                        level: aws_stepfunctions_1.LogLevel.ALL,
+                        includeExecutionData: true,
+                    };
+                }
+            }
+        }
+    }
+}
+exports.StepFunctionsDefaultsAspect = StepFunctionsDefaultsAspect;
+//# sourceMappingURL=data:application/json;base64,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

package/lib/{defaults/version-functions/version-functions.d.ts → lambda-sfn-versioning.d.ts}

@@ -20,7 +20,7 @@ import { IConstruct } from "constructs";
  * Aspects.of(app).add(new VersionFunctionsAspect({ alias: 'PROD' }));
  * ```
  */
-export declare class VersionFunctionsAspect implements IAspect {
+export declare class LambdaAndStepFunctionVersioningAspect implements IAspect {
     private readonly props;
     /**
      * Creates a new VersionFunctionsAspect

package/lib/lambda-sfn-versioning.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LambdaAndStepFunctionVersioningAspect = void 0;
+const aws_lambda_1 = require("aws-cdk-lib/aws-lambda");
+const aws_stepfunctions_1 = require("aws-cdk-lib/aws-stepfunctions");
+/**
+ * Aspect that automatically adds versioning and aliases to Lambda and Step Functions
+ *
+ * Visits all constructs in the scope and automatically creates versions and aliases
+ * for supported resource types. This enables blue-green deployments, traffic shifting,
+ * and provides stable ARNs for external integrations.
+ *
+ * Currently supports:
+ * - Lambda Functions: Creates function aliases
+ * - Step Functions: Creates versions and aliases with 100% traffic routing
+ *
+ * @example
+ * ```typescript
+ * // Apply to entire app for automatic versioning
+ * Aspects.of(app).add(new VersionFunctionsAspect());
+ *
+ * // Or with custom alias name
+ * Aspects.of(app).add(new VersionFunctionsAspect({ alias: 'PROD' }));
+ * ```
+ */
+class LambdaAndStepFunctionVersioningAspect {
+    /**
+     * Creates a new VersionFunctionsAspect
+     *
+     * @param props - Configuration for the aspect
+     * @param props.alias - Name for the alias to create. Defaults to 'LATEST'
+     */
+    constructor(props = {
+        alias: "LATEST",
+    }) {
+        this.props = props;
+    }
+    /**
+     * Visits a construct and applies versioning if it's a supported resource type
+     *
+     * For Lambda Functions: Adds a function alias pointing to $LATEST
+     * For Step Functions: Creates a version and alias with 100% traffic routing
+     *
+     * @param node - The construct to potentially add versioning to
+     */
+    visit(node) {
+        if (node instanceof aws_stepfunctions_1.StateMachine) {
+            const version = new aws_stepfunctions_1.CfnStateMachineVersion(node, `Version`, {
+                stateMachineArn: node.stateMachineArn,
+            });
+            new aws_stepfunctions_1.CfnStateMachineAlias(node, `Alias`, {
+                name: this.props.alias,
+                routingConfiguration: [
+                    {
+                        stateMachineVersionArn: version.attrArn,
+                        weight: 100,
+                    },
+                ],
+            });
+        }
+        if (node instanceof aws_lambda_1.Function) {
+            node.addAlias(this.props.alias);
+        }
+    }
+}
+exports.LambdaAndStepFunctionVersioningAspect = LambdaAndStepFunctionVersioningAspect;
+//# sourceMappingURL=data:application/json;base64,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

package/package.json

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

package/lib/defaults/version-functions/version-functions.js

@@ -1,67 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.VersionFunctionsAspect = void 0;
-const aws_lambda_1 = require("aws-cdk-lib/aws-lambda");
-const aws_stepfunctions_1 = require("aws-cdk-lib/aws-stepfunctions");
-/**
- * Aspect that automatically adds versioning and aliases to Lambda and Step Functions
- *
- * Visits all constructs in the scope and automatically creates versions and aliases
- * for supported resource types. This enables blue-green deployments, traffic shifting,
- * and provides stable ARNs for external integrations.
- *
- * Currently supports:
- * - Lambda Functions: Creates function aliases
- * - Step Functions: Creates versions and aliases with 100% traffic routing
- *
- * @example
- * ```typescript
- * // Apply to entire app for automatic versioning
- * Aspects.of(app).add(new VersionFunctionsAspect());
- *
- * // Or with custom alias name
- * Aspects.of(app).add(new VersionFunctionsAspect({ alias: 'PROD' }));
- * ```
- */
-class VersionFunctionsAspect {
-    /**
-     * Creates a new VersionFunctionsAspect
-     *
-     * @param props - Configuration for the aspect
-     * @param props.alias - Name for the alias to create. Defaults to 'LATEST'
-     */
-    constructor(props = {
-        alias: "LATEST",
-    }) {
-        this.props = props;
-    }
-    /**
-     * Visits a construct and applies versioning if it's a supported resource type
-     *
-     * For Lambda Functions: Adds a function alias pointing to $LATEST
-     * For Step Functions: Creates a version and alias with 100% traffic routing
-     *
-     * @param node - The construct to potentially add versioning to
-     */
-    visit(node) {
-        if (node instanceof aws_stepfunctions_1.StateMachine) {
-            const version = new aws_stepfunctions_1.CfnStateMachineVersion(node, `Version`, {
-                stateMachineArn: node.stateMachineArn,
-            });
-            new aws_stepfunctions_1.CfnStateMachineAlias(node, `Alias`, {
-                name: this.props.alias,
-                routingConfiguration: [
-                    {
-                        stateMachineVersionArn: version.attrArn,
-                        weight: 100,
-                    },
-                ],
-            });
-        }
-        if (node instanceof aws_lambda_1.Function) {
-            node.addAlias(this.props.alias);
-        }
-    }
-}
-exports.VersionFunctionsAspect = VersionFunctionsAspect;
-//# sourceMappingURL=data:application/json;base64,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