@cdklabs/cdk-appmod-catalog-blueprints 1.0.0

package/lib/utilities/data-loader.js

@@ -0,0 +1,447 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DataLoader = exports.FileType = exports.DatabaseEngine = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+const path = require("path");
+const aws_lambda_python_alpha_1 = require("@aws-cdk/aws-lambda-python-alpha");
+const aws_cdk_lib_1 = require("aws-cdk-lib");
+const aws_ec2_1 = require("aws-cdk-lib/aws-ec2");
+const aws_iam_1 = require("aws-cdk-lib/aws-iam");
+const aws_lambda_1 = require("aws-cdk-lib/aws-lambda");
+const aws_s3_1 = require("aws-cdk-lib/aws-s3");
+const aws_s3_deployment_1 = require("aws-cdk-lib/aws-s3-deployment");
+const aws_stepfunctions_1 = require("aws-cdk-lib/aws-stepfunctions");
+const aws_stepfunctions_tasks_1 = require("aws-cdk-lib/aws-stepfunctions-tasks");
+const custom_resources_1 = require("aws-cdk-lib/custom-resources");
+const constructs_1 = require("constructs");
+/**
+ * Supported database engines
+ */
+var DatabaseEngine;
+(function (DatabaseEngine) {
+    DatabaseEngine["MYSQL"] = "mysql";
+    DatabaseEngine["POSTGRESQL"] = "postgresql";
+})(DatabaseEngine || (exports.DatabaseEngine = DatabaseEngine = {}));
+/**
+ * Supported file types for data loading
+ */
+var FileType;
+(function (FileType) {
+    /** Standard SQL file */
+    FileType["SQL"] = "sql";
+    /** MySQL dump file generated by mysqldump */
+    FileType["MYSQLDUMP"] = "mysqldump";
+    /** PostgreSQL dump file generated by pg_dump */
+    FileType["PGDUMP"] = "pgdump";
+})(FileType || (exports.FileType = FileType = {}));
+/**
+ * DataLoader construct for loading data into Aurora/RDS databases
+ *
+ * This construct provides a simplified solution for loading data from various file formats
+ * (SQL, mysqldump, pg_dump) into MySQL or PostgreSQL databases. It uses S3 for file storage,
+ * Step Functions for orchestration, and Lambda for processing.
+ *
+ * Architecture:
+ * 1. Files are uploaded to S3 bucket
+ * 2. Step Function is triggered with list of S3 keys
+ * 3. Step Function iterates over files in execution order
+ * 4. Lambda function processes each file against the database
+ *
+ * Example usage:
+ * Create a DataLoader with database configuration and file inputs.
+ * The construct will handle uploading files to S3, creating a Step Function
+ * to orchestrate processing, and executing the data loading pipeline.
+ */
+class DataLoader extends constructs_1.Construct {
+    constructor(scope, id, props) {
+        super(scope, id);
+        // Store file inputs for later use
+        this.fileInputs = props.fileInputs;
+        // Validate props
+        this._validateProps(props);
+        // Get removal policy with default
+        const removalPolicy = props.removalPolicy || aws_cdk_lib_1.RemovalPolicy.DESTROY;
+        // Create S3 bucket for storing files
+        this.bucket = this._createBucket(removalPolicy);
+        // Create Lambda function for processing
+        this.processorFunction = this._createProcessorFunction(props);
+        // Create Step Functions state machine
+        this.stateMachine = this._createStateMachine();
+        // Create custom resource provider for triggering execution
+        this.customResourceProvider = this._createCustomResourceProvider();
+        // Upload files to S3
+        this._setupFileProcessing(props);
+        // Create custom resource to trigger execution after files are uploaded
+        this.executionTrigger = this._createExecutionTrigger();
+    }
+    /**
+     * Grants additional IAM permissions to the execution trigger Lambda function
+     * @param statement The IAM policy statement to add
+     */
+    grantExecutionTriggerPermissions(statement) {
+        // Get the Lambda function from the custom resource provider
+        const triggerFunction = this.customResourceProvider.onEventHandler;
+        if (triggerFunction) {
+            triggerFunction.addToRolePolicy(statement);
+        }
+    }
+    /**
+     * Validates the construct properties
+     * @param props The DataLoader properties
+     * @private
+     */
+    _validateProps(props) {
+        if (!props.databaseConfig) {
+            throw new Error('databaseConfig is required');
+        }
+        if (!props.databaseConfig.cluster && !props.databaseConfig.instance) {
+            throw new Error('Either cluster or instance must be provided in databaseConfig');
+        }
+        if (!props.fileInputs || props.fileInputs.length === 0) {
+            throw new Error('At least one file input is required');
+        }
+        // Validate file inputs
+        for (const fileInput of props.fileInputs) {
+            if (!fileInput.filePath) {
+                throw new Error('filePath is required for each file input');
+            }
+            if (!fileInput.fileType) {
+                throw new Error('fileType is required for each file input');
+            }
+        }
+        // Validate engine compatibility
+        for (const fileInput of props.fileInputs) {
+            if (props.databaseConfig.engine === DatabaseEngine.MYSQL &&
+                fileInput.fileType === FileType.PGDUMP) {
+                throw new Error('PostgreSQL dump files cannot be used with MySQL databases');
+            }
+            if (props.databaseConfig.engine === DatabaseEngine.POSTGRESQL &&
+                fileInput.fileType === FileType.MYSQLDUMP) {
+                throw new Error('MySQL dump files cannot be used with PostgreSQL databases');
+            }
+        }
+    }
+    /**
+     * Creates the S3 bucket for storing files
+     * @param removalPolicy The removal policy to apply
+     * @returns The created S3 bucket
+     * @private
+     */
+    _createBucket(removalPolicy) {
+        const bucket = new aws_s3_1.Bucket(this, 'DataLoaderBucket', {
+            encryption: aws_s3_1.BucketEncryption.S3_MANAGED,
+            blockPublicAccess: aws_s3_1.BlockPublicAccess.BLOCK_ALL,
+            removalPolicy: removalPolicy,
+            autoDeleteObjects: removalPolicy === aws_cdk_lib_1.RemovalPolicy.DESTROY,
+        });
+        return bucket;
+    }
+    /**
+     * Creates the Lambda function for processing data loading
+     * @param props The DataLoader properties
+     * @returns The created Lambda function
+     * @private
+     */
+    _createProcessorFunction(props) {
+        // Create a dedicated security group for the Lambda function
+        const lambdaSecurityGroup = new aws_ec2_1.SecurityGroup(this, 'DataLoaderProcessorSecurityGroup', {
+            vpc: props.databaseConfig.vpc,
+            description: 'Security group for DataLoader processor Lambda function',
+            allowAllOutbound: true, // Lambda needs outbound access for AWS services and internet
+        });
+        // Allow Lambda to connect to the database
+        // Add ingress rule to database security group to allow connections from Lambda
+        props.databaseConfig.securityGroup.addIngressRule(lambdaSecurityGroup, aws_ec2_1.Port.tcp(props.databaseConfig.engine === DatabaseEngine.MYSQL ? 3306 : 5432), `Allow DataLoader Lambda to connect to ${props.databaseConfig.engine} database`);
+        // Create Lambda function with automatic dependency bundling
+        const lambdaFunction = new aws_lambda_python_alpha_1.PythonFunction(this, 'DataLoaderProcessor', {
+            entry: path.join(__dirname, 'data-loader-lambda'),
+            runtime: aws_lambda_1.Runtime.PYTHON_3_13,
+            handler: 'handler',
+            index: 'index.py',
+            timeout: props.timeout || aws_cdk_lib_1.Duration.minutes(15),
+            memorySize: props.memorySize || 1024,
+            architecture: aws_lambda_1.Architecture.ARM_64,
+            vpc: props.databaseConfig.vpc,
+            securityGroups: [lambdaSecurityGroup], // Use the dedicated Lambda security group
+            environment: {
+                DATABASE_ENGINE: props.databaseConfig.engine,
+                DATABASE_SECRET_ARN: props.databaseConfig.secret.secretArn,
+                DATABASE_NAME: props.databaseConfig.databaseName,
+                S3_BUCKET: this.bucket.bucketName,
+            },
+            bundling: {
+                // Use custom bundling commands to avoid Poetry conflicts
+                command: [
+                    'bash', '-c', [
+                        // Create a clean virtual environment
+                        'python -m venv /tmp/venv',
+                        // Activate the virtual environment
+                        'source /tmp/venv/bin/activate',
+                        // Install dependencies in the virtual environment
+                        'pip install --upgrade pip',
+                        'pip install -r requirements.txt -t /asset-output',
+                        // Copy source files
+                        'cp -r . /asset-output',
+                        // Clean up __pycache__ and other unnecessary files
+                        'find /asset-output -type d -name __pycache__ -exec rm -rf {} + || true',
+                        'find /asset-output -name "*.pyc" -delete || true',
+                    ].join(' && '),
+                ],
+                // Use the standard Python image to avoid pre-installed packages
+                image: aws_cdk_lib_1.DockerImage.fromRegistry('public.ecr.aws/docker/library/python:3.13.5-bullseye'),
+            },
+        });
+        // Grant permissions
+        this._grantPermissions(lambdaFunction, props);
+        return lambdaFunction;
+    }
+    /**
+     * Creates the Step Functions state machine
+     * @returns The created state machine
+     * @private
+     */
+    _createStateMachine() {
+        // Create a Map state to iterate over file keys
+        const processFileTask = new aws_stepfunctions_tasks_1.LambdaInvoke(this, 'ProcessFileTask', {
+            lambdaFunction: this.processorFunction,
+            payload: aws_stepfunctions_1.TaskInput.fromObject({
+                's3Key.$': '$',
+                'bucketName': this.bucket.bucketName,
+            }),
+        });
+        // Create the state machine definition
+        const definition = new aws_stepfunctions_1.Map(this, 'ProcessFilesMap', {
+            itemsPath: '$.fileKeys',
+            maxConcurrency: 1, // Process files sequentially to maintain order
+        }).itemProcessor(processFileTask);
+        // Create the state machine
+        const stateMachine = new aws_stepfunctions_1.StateMachine(this, 'DataLoaderStateMachine', {
+            definitionBody: aws_stepfunctions_1.DefinitionBody.fromChainable(definition),
+            timeout: aws_cdk_lib_1.Duration.hours(2), // Allow up to 2 hours for the entire process
+        });
+        // Grant the state machine permission to invoke the Lambda function
+        this.processorFunction.grantInvoke(stateMachine);
+        return stateMachine;
+    }
+    /**
+     * Grants necessary permissions to the Lambda function
+     * @param lambdaFunction The Lambda function
+     * @param props The DataLoader properties
+     * @private
+     */
+    _grantPermissions(lambdaFunction, props) {
+        // Grant S3 permissions
+        this.bucket.grantRead(lambdaFunction);
+        // Grant Secrets Manager permissions
+        props.databaseConfig.secret.grantRead(lambdaFunction);
+    }
+    /**
+     * Sets up file processing by uploading files to S3
+     * @param props The DataLoader properties
+     * @private
+     */
+    _setupFileProcessing(props) {
+        // Separate local files from S3 URIs
+        const localFiles = props.fileInputs.filter(f => !f.filePath.startsWith('s3://'));
+        // Upload local files to S3 if any
+        if (localFiles.length > 0) {
+            // Process each file individually to handle both files and directories
+            localFiles.forEach((fileInput, index) => {
+                const filePath = fileInput.filePath;
+                // eslint-disable-next-line @typescript-eslint/no-require-imports
+                const fs = require('fs');
+                // eslint-disable-next-line @typescript-eslint/no-require-imports
+                const pathModule = require('path');
+                let resolvedPath;
+                if (pathModule.isAbsolute(filePath)) {
+                    resolvedPath = filePath;
+                }
+                else {
+                    // Resolve relative paths from the current working directory
+                    resolvedPath = pathModule.resolve(filePath);
+                }
+                // Check if the path exists
+                if (!fs.existsSync(resolvedPath)) {
+                    throw new Error(`File not found: ${resolvedPath}`);
+                }
+                if (fs.statSync(resolvedPath).isFile()) {
+                    // For individual files, deploy from parent directory with include filter
+                    const parentDir = pathModule.dirname(resolvedPath);
+                    const fileName = pathModule.basename(resolvedPath);
+                    new aws_s3_deployment_1.BucketDeployment(this, `DataLoaderFileDeployment${index}`, {
+                        sources: [aws_s3_deployment_1.Source.asset(parentDir)],
+                        destinationBucket: this.bucket,
+                        destinationKeyPrefix: 'data-files/',
+                        include: [fileName],
+                    });
+                }
+                else {
+                    // For directories, deploy entire directory
+                    new aws_s3_deployment_1.BucketDeployment(this, `DataLoaderFileDeployment${index}`, {
+                        sources: [aws_s3_deployment_1.Source.asset(resolvedPath)],
+                        destinationBucket: this.bucket,
+                        destinationKeyPrefix: 'data-files/',
+                    });
+                }
+            });
+        }
+    }
+    /**
+     * Creates a custom resource provider for triggering state machine execution
+     * @returns The custom resource provider
+     * @private
+     */
+    _createCustomResourceProvider() {
+        // Create IAM role for the custom resource Lambda function with all necessary policies
+        const customResourceRole = new aws_iam_1.Role(this, 'StateMachineExecutionTriggerRole', {
+            assumedBy: new aws_iam_1.ServicePrincipal('lambda.amazonaws.com'),
+            description: 'IAM role for DataLoader custom resource Lambda function',
+            managedPolicies: [
+                aws_iam_1.ManagedPolicy.fromAwsManagedPolicyName('service-role/AWSLambdaBasicExecutionRole'),
+            ],
+            inlinePolicies: {
+                StateMachineExecutionPolicy: new aws_iam_1.PolicyDocument({
+                    statements: [
+                        new aws_iam_1.PolicyStatement({
+                            effect: aws_iam_1.Effect.ALLOW,
+                            actions: [
+                                'states:StartExecution',
+                                'states:DescribeExecution',
+                                'states:StopExecution',
+                            ],
+                            resources: [
+                                this.stateMachine.stateMachineArn,
+                                `${this.stateMachine.stateMachineArn}:*`, // For execution ARNs
+                            ],
+                        }),
+                    ],
+                }),
+            },
+        });
+        // Create Lambda function for custom resource with the pre-configured role
+        const customResourceFunction = new aws_lambda_1.Function(this, 'StateMachineExecutionTrigger', {
+            runtime: aws_lambda_1.Runtime.PYTHON_3_11,
+            handler: 'index.handler',
+            role: customResourceRole, // Attach the role during creation
+            code: aws_lambda_1.Code.fromInline(`
+import json
+import boto3
+import logging
+
+logger = logging.getLogger()
+logger.setLevel(logging.INFO)
+
+stepfunctions = boto3.client('stepfunctions')
+
+def handler(event, context):
+    logger.info(f"Received event: {json.dumps(event)}")
+    
+    request_type = event['RequestType']
+    
+    if request_type == 'Create' or request_type == 'Update':
+        try:
+            # Get parameters from event
+            state_machine_arn = event['ResourceProperties']['StateMachineArn']
+            file_keys = event['ResourceProperties']['FileKeys']
+            
+            # Start execution
+            response = stepfunctions.start_execution(
+                stateMachineArn=state_machine_arn,
+                input=json.dumps({
+                    'fileKeys': file_keys
+                })
+            )
+            
+            execution_arn = response['executionArn']
+            logger.info(f"Started execution: {execution_arn}")
+            
+            return {
+                'Status': 'SUCCESS',
+                'PhysicalResourceId': execution_arn,
+                'Data': {
+                    'ExecutionArn': execution_arn
+                }
+            }
+            
+        except Exception as e:
+            logger.error(f"Error starting execution: {str(e)}")
+            return {
+                'Status': 'FAILED',
+                'Reason': str(e),
+                'PhysicalResourceId': 'failed'
+            }
+    
+    elif request_type == 'Delete':
+        # For delete, we don't need to do anything special
+        return {
+            'Status': 'SUCCESS',
+            'PhysicalResourceId': event.get('PhysicalResourceId', 'none')
+        }
+    
+    return {
+        'Status': 'SUCCESS',
+        'PhysicalResourceId': 'none'
+    }
+      `),
+            timeout: aws_cdk_lib_1.Duration.minutes(5),
+        });
+        // Create provider with the Lambda function that already has the correct role
+        const provider = new custom_resources_1.Provider(this, 'StateMachineExecutionProvider', {
+            onEventHandler: customResourceFunction,
+        });
+        return provider;
+    }
+    /**
+     * Creates a custom resource to trigger state machine execution
+     * @returns The custom resource
+     * @private
+     */
+    _createExecutionTrigger() {
+        // Get ordered file keys
+        const orderedFileKeys = this._getOrderedFileKeys();
+        const customResource = new aws_cdk_lib_1.CustomResource(this, 'ExecutionTriggerResource', {
+            serviceToken: this.customResourceProvider.serviceToken,
+            properties: {
+                StateMachineArn: this.stateMachine.stateMachineArn,
+                FileKeys: orderedFileKeys,
+                // Add a timestamp to force updates when needed
+                Timestamp: Date.now().toString(),
+            },
+        });
+        // Ensure the custom resource runs after bucket deployment (if exists)
+        if (this.bucketDeployment) {
+            customResource.node.addDependency(this.stateMachine);
+            customResource.node.addDependency(this.bucketDeployment);
+        }
+        return customResource;
+    }
+    /**
+     * Gets the ordered file keys for execution
+     * @returns Array of S3 keys in execution order
+     * @private
+     */
+    _getOrderedFileKeys() {
+        // Sort files by execution order
+        const sortedFiles = [...this.fileInputs].sort((a, b) => (a.executionOrder || 0) - (b.executionOrder || 0));
+        // Convert file paths to S3 keys
+        return sortedFiles.map(file => {
+            if (file.filePath.startsWith('s3://')) {
+                // Extract key from S3 URI
+                const parts = file.filePath.replace('s3://', '').split('/');
+                return parts.slice(1).join('/'); // Remove bucket name
+            }
+            else {
+                // Local files are uploaded with data-files/ prefix
+                const fileName = path.basename(file.filePath);
+                return `data-files/${fileName}`;
+            }
+        });
+    }
+}
+exports.DataLoader = DataLoader;
+_a = JSII_RTTI_SYMBOL_1;
+DataLoader[_a] = { fqn: "@cdklabs/cdk-appmod-catalog-blueprints.DataLoader", version: "1.0.0" };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"data-loader.js","sourceRoot":"","sources":["../../use-cases/utilities/data-loader.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.\n// SPDX-License-Identifier: Apache-2.0\n\nimport * as path from 'path';\nimport { PythonFunction } from '@aws-cdk/aws-lambda-python-alpha';\nimport { Duration, RemovalPolicy, CustomResource, DockerImage } from 'aws-cdk-lib';\nimport { IVpc, SecurityGroup, Port, ISecurityGroup } from 'aws-cdk-lib/aws-ec2';\nimport { PolicyStatement, Role, ServicePrincipal, ManagedPolicy, PolicyDocument, Effect } from 'aws-cdk-lib/aws-iam';\nimport { Architecture, Code, Function as LambdaFunction, Runtime } from 'aws-cdk-lib/aws-lambda';\nimport { IDatabaseCluster, IDatabaseInstance } from 'aws-cdk-lib/aws-rds';\nimport { Bucket, BucketEncryption, BlockPublicAccess } from 'aws-cdk-lib/aws-s3';\nimport { BucketDeployment, Source } from 'aws-cdk-lib/aws-s3-deployment';\nimport { ISecret } from 'aws-cdk-lib/aws-secretsmanager';\nimport { StateMachine, DefinitionBody, Map, TaskInput } from 'aws-cdk-lib/aws-stepfunctions';\nimport { LambdaInvoke } from 'aws-cdk-lib/aws-stepfunctions-tasks';\nimport { Provider } from 'aws-cdk-lib/custom-resources';\nimport { Construct } from 'constructs';\n\n/**\n * Supported database engines\n */\nexport enum DatabaseEngine {\n  MYSQL = 'mysql',\n  POSTGRESQL = 'postgresql',\n}\n\n/**\n * Supported file types for data loading\n */\nexport enum FileType {\n  /** Standard SQL file */\n  SQL = 'sql',\n  /** MySQL dump file generated by mysqldump */\n  MYSQLDUMP = 'mysqldump',\n  /** PostgreSQL dump file generated by pg_dump */\n  PGDUMP = 'pgdump',\n}\n\n/**\n * Database connection configuration\n */\nexport interface DatabaseConfig {\n  /** Database engine type */\n  readonly engine: DatabaseEngine;\n  /** Database cluster (for Aurora) */\n  readonly cluster?: IDatabaseCluster;\n  /** Database instance (for RDS) */\n  readonly instance?: IDatabaseInstance;\n  /** Database credentials secret */\n  readonly secret: ISecret;\n  /** Database name to connect to */\n  readonly databaseName: string;\n  /** VPC where the database is located */\n  readonly vpc: IVpc;\n  /** Security group for database access */\n  readonly securityGroup: ISecurityGroup;\n}\n\n/**\n * File input configuration\n */\nexport interface FileInput {\n  /** Path to the file (local path or S3 URI) */\n  readonly filePath: string;\n  /** Type of file */\n  readonly fileType: FileType;\n  /** Execution order (lower numbers execute first) */\n  readonly executionOrder?: number;\n  /** Whether to continue on error */\n  readonly continueOnError?: boolean;\n}\n\n/**\n * Properties for the DataLoader construct\n */\nexport interface DataLoaderProps {\n  /** Database configuration */\n  readonly databaseConfig: DatabaseConfig;\n  /** List of files to load */\n  readonly fileInputs: FileInput[];\n  /** Optional removal policy for resources (defaults to DESTROY) */\n  readonly removalPolicy?: RemovalPolicy;\n  /** Optional timeout for Lambda function (defaults to 15 minutes) */\n  readonly timeout?: Duration;\n  /** Optional memory size for Lambda function (defaults to 1024 MB) */\n  readonly memorySize?: number;\n}\n\n/**\n * DataLoader construct for loading data into Aurora/RDS databases\n *\n * This construct provides a simplified solution for loading data from various file formats\n * (SQL, mysqldump, pg_dump) into MySQL or PostgreSQL databases. It uses S3 for file storage,\n * Step Functions for orchestration, and Lambda for processing.\n *\n * Architecture:\n * 1. Files are uploaded to S3 bucket\n * 2. Step Function is triggered with list of S3 keys\n * 3. Step Function iterates over files in execution order\n * 4. Lambda function processes each file against the database\n *\n * Example usage:\n * Create a DataLoader with database configuration and file inputs.\n * The construct will handle uploading files to S3, creating a Step Function\n * to orchestrate processing, and executing the data loading pipeline.\n */\nexport class DataLoader extends Construct {\n  /** The S3 bucket used for storing files */\n  public readonly bucket: Bucket;\n  /** The Step Functions state machine for orchestration */\n  public readonly stateMachine: StateMachine;\n  /** The Lambda function that processes the data loading */\n  public readonly processorFunction: LambdaFunction;\n  /** The bucket deployment for uploading files */\n  public bucketDeployment?: BucketDeployment;\n  /** The custom resource provider for triggering state machine execution */\n  public readonly customResourceProvider: Provider;\n  /** The custom resource that triggers the state machine */\n  public readonly executionTrigger: CustomResource;\n  /** The file inputs configuration */\n  private readonly fileInputs: FileInput[];\n\n  constructor(scope: Construct, id: string, props: DataLoaderProps) {\n    super(scope, id);\n\n    // Store file inputs for later use\n    this.fileInputs = props.fileInputs;\n\n    // Validate props\n    this._validateProps(props);\n\n    // Get removal policy with default\n    const removalPolicy = props.removalPolicy || RemovalPolicy.DESTROY;\n\n    // Create S3 bucket for storing files\n    this.bucket = this._createBucket(removalPolicy);\n\n    // Create Lambda function for processing\n    this.processorFunction = this._createProcessorFunction(props);\n\n    // Create Step Functions state machine\n    this.stateMachine = this._createStateMachine();\n\n    // Create custom resource provider for triggering execution\n    this.customResourceProvider = this._createCustomResourceProvider();\n\n    // Upload files to S3\n    this._setupFileProcessing(props);\n\n    // Create custom resource to trigger execution after files are uploaded\n    this.executionTrigger = this._createExecutionTrigger();\n  }\n\n  /**\n   * Grants additional IAM permissions to the execution trigger Lambda function\n   * @param statement The IAM policy statement to add\n   */\n  public grantExecutionTriggerPermissions(statement: PolicyStatement): void {\n    // Get the Lambda function from the custom resource provider\n    const triggerFunction = this.customResourceProvider.onEventHandler;\n    if (triggerFunction) {\n      triggerFunction.addToRolePolicy(statement);\n    }\n  }\n\n  /**\n   * Validates the construct properties\n   * @param props The DataLoader properties\n   * @private\n   */\n  private _validateProps(props: DataLoaderProps): void {\n    if (!props.databaseConfig) {\n      throw new Error('databaseConfig is required');\n    }\n\n    if (!props.databaseConfig.cluster && !props.databaseConfig.instance) {\n      throw new Error('Either cluster or instance must be provided in databaseConfig');\n    }\n\n    if (!props.fileInputs || props.fileInputs.length === 0) {\n      throw new Error('At least one file input is required');\n    }\n\n    // Validate file inputs\n    for (const fileInput of props.fileInputs) {\n      if (!fileInput.filePath) {\n        throw new Error('filePath is required for each file input');\n      }\n      if (!fileInput.fileType) {\n        throw new Error('fileType is required for each file input');\n      }\n    }\n\n    // Validate engine compatibility\n    for (const fileInput of props.fileInputs) {\n      if (props.databaseConfig.engine === DatabaseEngine.MYSQL &&\n          fileInput.fileType === FileType.PGDUMP) {\n        throw new Error('PostgreSQL dump files cannot be used with MySQL databases');\n      }\n      if (props.databaseConfig.engine === DatabaseEngine.POSTGRESQL &&\n          fileInput.fileType === FileType.MYSQLDUMP) {\n        throw new Error('MySQL dump files cannot be used with PostgreSQL databases');\n      }\n    }\n  }\n\n  /**\n   * Creates the S3 bucket for storing files\n   * @param removalPolicy The removal policy to apply\n   * @returns The created S3 bucket\n   * @private\n   */\n  private _createBucket(removalPolicy: RemovalPolicy): Bucket {\n    const bucket = new Bucket(this, 'DataLoaderBucket', {\n      encryption: BucketEncryption.S3_MANAGED,\n      blockPublicAccess: BlockPublicAccess.BLOCK_ALL,\n      removalPolicy: removalPolicy,\n      autoDeleteObjects: removalPolicy === RemovalPolicy.DESTROY,\n    });\n\n    return bucket;\n  }\n\n  /**\n   * Creates the Lambda function for processing data loading\n   * @param props The DataLoader properties\n   * @returns The created Lambda function\n   * @private\n   */\n  private _createProcessorFunction(props: DataLoaderProps): LambdaFunction {\n    // Create a dedicated security group for the Lambda function\n    const lambdaSecurityGroup = new SecurityGroup(this, 'DataLoaderProcessorSecurityGroup', {\n      vpc: props.databaseConfig.vpc,\n      description: 'Security group for DataLoader processor Lambda function',\n      allowAllOutbound: true, // Lambda needs outbound access for AWS services and internet\n    });\n\n    // Allow Lambda to connect to the database\n    // Add ingress rule to database security group to allow connections from Lambda\n    props.databaseConfig.securityGroup.addIngressRule(\n      lambdaSecurityGroup,\n      Port.tcp(props.databaseConfig.engine === DatabaseEngine.MYSQL ? 3306 : 5432),\n      `Allow DataLoader Lambda to connect to ${props.databaseConfig.engine} database`,\n    );\n\n    // Create Lambda function with automatic dependency bundling\n    const lambdaFunction = new PythonFunction(this, 'DataLoaderProcessor', {\n      entry: path.join(__dirname, 'data-loader-lambda'),\n      runtime: Runtime.PYTHON_3_13,\n      handler: 'handler',\n      index: 'index.py',\n      timeout: props.timeout || Duration.minutes(15),\n      memorySize: props.memorySize || 1024,\n      architecture: Architecture.ARM_64,\n      vpc: props.databaseConfig.vpc,\n      securityGroups: [lambdaSecurityGroup], // Use the dedicated Lambda security group\n      environment: {\n        DATABASE_ENGINE: props.databaseConfig.engine,\n        DATABASE_SECRET_ARN: props.databaseConfig.secret.secretArn,\n        DATABASE_NAME: props.databaseConfig.databaseName,\n        S3_BUCKET: this.bucket.bucketName,\n      },\n      bundling: {\n        // Use custom bundling commands to avoid Poetry conflicts\n        command: [\n          'bash', '-c', [\n            // Create a clean virtual environment\n            'python -m venv /tmp/venv',\n            // Activate the virtual environment\n            'source /tmp/venv/bin/activate',\n            // Install dependencies in the virtual environment\n            'pip install --upgrade pip',\n            'pip install -r requirements.txt -t /asset-output',\n            // Copy source files\n            'cp -r . /asset-output',\n            // Clean up __pycache__ and other unnecessary files\n            'find /asset-output -type d -name __pycache__ -exec rm -rf {} + || true',\n            'find /asset-output -name \"*.pyc\" -delete || true',\n          ].join(' && '),\n        ],\n        // Use the standard Python image to avoid pre-installed packages\n        image: DockerImage.fromRegistry('public.ecr.aws/docker/library/python:3.13.5-bullseye'),\n      },\n    });\n\n    // Grant permissions\n    this._grantPermissions(lambdaFunction, props);\n\n    return lambdaFunction;\n  }\n\n  /**\n   * Creates the Step Functions state machine\n   * @returns The created state machine\n   * @private\n   */\n  private _createStateMachine(): StateMachine {\n    // Create a Map state to iterate over file keys\n    const processFileTask = new LambdaInvoke(this, 'ProcessFileTask', {\n      lambdaFunction: this.processorFunction,\n      payload: TaskInput.fromObject({\n        's3Key.$': '$',\n        'bucketName': this.bucket.bucketName,\n      }),\n    });\n\n    // Create the state machine definition\n    const definition = new Map(this, 'ProcessFilesMap', {\n      itemsPath: '$.fileKeys',\n      maxConcurrency: 1, // Process files sequentially to maintain order\n    }).itemProcessor(processFileTask);\n\n    // Create the state machine\n    const stateMachine = new StateMachine(this, 'DataLoaderStateMachine', {\n      definitionBody: DefinitionBody.fromChainable(definition),\n      timeout: Duration.hours(2), // Allow up to 2 hours for the entire process\n    });\n\n    // Grant the state machine permission to invoke the Lambda function\n    this.processorFunction.grantInvoke(stateMachine);\n\n    return stateMachine;\n  }\n\n  /**\n   * Grants necessary permissions to the Lambda function\n   * @param lambdaFunction The Lambda function\n   * @param props The DataLoader properties\n   * @private\n   */\n  private _grantPermissions(lambdaFunction: LambdaFunction, props: DataLoaderProps): void {\n    // Grant S3 permissions\n    this.bucket.grantRead(lambdaFunction);\n\n    // Grant Secrets Manager permissions\n    props.databaseConfig.secret.grantRead(lambdaFunction);\n  }\n\n  /**\n   * Sets up file processing by uploading files to S3\n   * @param props The DataLoader properties\n   * @private\n   */\n  private _setupFileProcessing(props: DataLoaderProps): void {\n    // Separate local files from S3 URIs\n    const localFiles = props.fileInputs.filter(f => !f.filePath.startsWith('s3://'));\n\n    // Upload local files to S3 if any\n    if (localFiles.length > 0) {\n      // Process each file individually to handle both files and directories\n      localFiles.forEach((fileInput, index) => {\n        const filePath = fileInput.filePath;\n        // eslint-disable-next-line @typescript-eslint/no-require-imports\n        const fs = require('fs');\n        // eslint-disable-next-line @typescript-eslint/no-require-imports\n        const pathModule = require('path');\n\n        let resolvedPath: string;\n        if (pathModule.isAbsolute(filePath)) {\n          resolvedPath = filePath;\n        } else {\n          // Resolve relative paths from the current working directory\n          resolvedPath = pathModule.resolve(filePath);\n        }\n\n        // Check if the path exists\n        if (!fs.existsSync(resolvedPath)) {\n          throw new Error(`File not found: ${resolvedPath}`);\n        }\n\n        if (fs.statSync(resolvedPath).isFile()) {\n          // For individual files, deploy from parent directory with include filter\n          const parentDir = pathModule.dirname(resolvedPath);\n          const fileName = pathModule.basename(resolvedPath);\n\n          new BucketDeployment(this, `DataLoaderFileDeployment${index}`, {\n            sources: [Source.asset(parentDir)],\n            destinationBucket: this.bucket,\n            destinationKeyPrefix: 'data-files/',\n            include: [fileName],\n          });\n        } else {\n          // For directories, deploy entire directory\n          new BucketDeployment(this, `DataLoaderFileDeployment${index}`, {\n            sources: [Source.asset(resolvedPath)],\n            destinationBucket: this.bucket,\n            destinationKeyPrefix: 'data-files/',\n          });\n        }\n      });\n    }\n  }\n\n  /**\n   * Creates a custom resource provider for triggering state machine execution\n   * @returns The custom resource provider\n   * @private\n   */\n  private _createCustomResourceProvider(): Provider {\n    // Create IAM role for the custom resource Lambda function with all necessary policies\n    const customResourceRole = new Role(this, 'StateMachineExecutionTriggerRole', {\n      assumedBy: new ServicePrincipal('lambda.amazonaws.com'),\n      description: 'IAM role for DataLoader custom resource Lambda function',\n      managedPolicies: [\n        ManagedPolicy.fromAwsManagedPolicyName('service-role/AWSLambdaBasicExecutionRole'),\n      ],\n      inlinePolicies: {\n        StateMachineExecutionPolicy: new PolicyDocument({\n          statements: [\n            new PolicyStatement({\n              effect: Effect.ALLOW,\n              actions: [\n                'states:StartExecution',\n                'states:DescribeExecution',\n                'states:StopExecution',\n              ],\n              resources: [\n                this.stateMachine.stateMachineArn,\n                `${this.stateMachine.stateMachineArn}:*`, // For execution ARNs\n              ],\n            }),\n          ],\n        }),\n      },\n    });\n\n    // Create Lambda function for custom resource with the pre-configured role\n    const customResourceFunction = new LambdaFunction(this, 'StateMachineExecutionTrigger', {\n      runtime: Runtime.PYTHON_3_11,\n      handler: 'index.handler',\n      role: customResourceRole, // Attach the role during creation\n      code: Code.fromInline(`\nimport json\nimport boto3\nimport logging\n\nlogger = logging.getLogger()\nlogger.setLevel(logging.INFO)\n\nstepfunctions = boto3.client('stepfunctions')\n\ndef handler(event, context):\n    logger.info(f\"Received event: {json.dumps(event)}\")\n    \n    request_type = event['RequestType']\n    \n    if request_type == 'Create' or request_type == 'Update':\n        try:\n            # Get parameters from event\n            state_machine_arn = event['ResourceProperties']['StateMachineArn']\n            file_keys = event['ResourceProperties']['FileKeys']\n            \n            # Start execution\n            response = stepfunctions.start_execution(\n                stateMachineArn=state_machine_arn,\n                input=json.dumps({\n                    'fileKeys': file_keys\n                })\n            )\n            \n            execution_arn = response['executionArn']\n            logger.info(f\"Started execution: {execution_arn}\")\n            \n            return {\n                'Status': 'SUCCESS',\n                'PhysicalResourceId': execution_arn,\n                'Data': {\n                    'ExecutionArn': execution_arn\n                }\n            }\n            \n        except Exception as e:\n            logger.error(f\"Error starting execution: {str(e)}\")\n            return {\n                'Status': 'FAILED',\n                'Reason': str(e),\n                'PhysicalResourceId': 'failed'\n            }\n    \n    elif request_type == 'Delete':\n        # For delete, we don't need to do anything special\n        return {\n            'Status': 'SUCCESS',\n            'PhysicalResourceId': event.get('PhysicalResourceId', 'none')\n        }\n    \n    return {\n        'Status': 'SUCCESS',\n        'PhysicalResourceId': 'none'\n    }\n      `),\n      timeout: Duration.minutes(5),\n    });\n\n    // Create provider with the Lambda function that already has the correct role\n    const provider = new Provider(this, 'StateMachineExecutionProvider', {\n      onEventHandler: customResourceFunction,\n    });\n\n    return provider;\n  }\n\n  /**\n   * Creates a custom resource to trigger state machine execution\n   * @returns The custom resource\n   * @private\n   */\n  private _createExecutionTrigger(): CustomResource {\n    // Get ordered file keys\n    const orderedFileKeys = this._getOrderedFileKeys();\n\n    const customResource = new CustomResource(this, 'ExecutionTriggerResource', {\n      serviceToken: this.customResourceProvider.serviceToken,\n      properties: {\n        StateMachineArn: this.stateMachine.stateMachineArn,\n        FileKeys: orderedFileKeys,\n        // Add a timestamp to force updates when needed\n        Timestamp: Date.now().toString(),\n      },\n    });\n\n    // Ensure the custom resource runs after bucket deployment (if exists)\n    if (this.bucketDeployment) {\n      customResource.node.addDependency(this.stateMachine);\n      customResource.node.addDependency(this.bucketDeployment);\n    }\n\n    return customResource;\n  }\n\n  /**\n   * Gets the ordered file keys for execution\n   * @returns Array of S3 keys in execution order\n   * @private\n   */\n  private _getOrderedFileKeys(): string[] {\n    // Sort files by execution order\n    const sortedFiles = [...this.fileInputs].sort(\n      (a, b) => (a.executionOrder || 0) - (b.executionOrder || 0),\n    );\n\n    // Convert file paths to S3 keys\n    return sortedFiles.map(file => {\n      if (file.filePath.startsWith('s3://')) {\n        // Extract key from S3 URI\n        const parts = file.filePath.replace('s3://', '').split('/');\n        return parts.slice(1).join('/'); // Remove bucket name\n      } else {\n        // Local files are uploaded with data-files/ prefix\n        const fileName = path.basename(file.filePath);\n        return `data-files/${fileName}`;\n      }\n    });\n  }\n}\n"]}

package/lib/utilities/index.d.ts

@@ -0,0 +1,3 @@
+export * from './observability';
+export * from './lambda-iam-utils';
+export * from './data-loader';

package/lib/utilities/index.js

@@ -0,0 +1,20 @@
+"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 });
+__exportStar(require("./observability"), exports);
+__exportStar(require("./lambda-iam-utils"), exports);
+__exportStar(require("./data-loader"), exports);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi91c2UtY2FzZXMvdXRpbGl0aWVzL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7Ozs7Ozs7QUFBQSxrREFBZ0M7QUFDaEMscURBQW1DO0FBQ25DLGdEQUE4QiIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vb2JzZXJ2YWJpbGl0eSc7XG5leHBvcnQgKiBmcm9tICcuL2xhbWJkYS1pYW0tdXRpbHMnO1xuZXhwb3J0ICogZnJvbSAnLi9kYXRhLWxvYWRlcic7XG4iXX0=