@jaypie/constructs 1.1.21 → 1.1.23

package/dist/esm/index.js

@@ -1,16 +1,607 @@
-import { Construct } from 'constructs';
 import * as cdk from 'aws-cdk-lib';
-import { Fn, CfnOutput, SecretValue, Tags, Stack, Duration } from 'aws-cdk-lib';
-import * as secretsmanager from 'aws-cdk-lib/aws-secretsmanager';
+import { Duration, Stack, Tags, RemovalPolicy, Fn, CfnOutput, SecretValue } from 'aws-cdk-lib';
+import * as s3 from 'aws-cdk-lib/aws-s3';
+import * as s3n from 'aws-cdk-lib/aws-s3-notifications';
 import { CDK } from '@jaypie/cdk';
-import { ServicePrincipal } from 'aws-cdk-lib/aws-iam';
-import { LogGroup, RetentionDays, FilterPattern } from 'aws-cdk-lib/aws-logs';
-import { HostedZone } from 'aws-cdk-lib/aws-route53';
+import { Construct } from 'constructs';
 import * as lambda from 'aws-cdk-lib/aws-lambda';
 import * as sqs from 'aws-cdk-lib/aws-sqs';
 import * as lambdaEventSources from 'aws-cdk-lib/aws-lambda-event-sources';
+import * as secretsmanager from 'aws-cdk-lib/aws-secretsmanager';
+import { ServicePrincipal } from 'aws-cdk-lib/aws-iam';
+import { LogGroup, RetentionDays, FilterPattern } from 'aws-cdk-lib/aws-logs';
+import { HostedZone } from 'aws-cdk-lib/aws-route53';
 import * as sso from 'aws-cdk-lib/aws-sso';
 
+class JaypieLambda extends Construct {
+    constructor(scope, id, props) {
+        super(scope, id);
+        const { code, datadogApiKeyArn, environment: initialEnvironment = {}, envSecrets = {}, handler = "index.handler", layers = [], logRetention = CDK.LAMBDA.LOG_RETENTION, memorySize = CDK.LAMBDA.MEMORY_SIZE, paramsAndSecrets, paramsAndSecretsOptions, reservedConcurrentExecutions, roleTag, runtime = lambda.Runtime.NODEJS_20_X, secrets = [], timeout = Duration.seconds(CDK.DURATION.LAMBDA_WORKER), vendorTag, } = props;
+        // Create a mutable copy of the environment variables
+        let environment = { ...initialEnvironment };
+        this._code = typeof code === "string" ? lambda.Code.fromAsset(code) : code;
+        // Create a working copy of layers
+        const resolvedLayers = [...layers];
+        // Determine if we should add Datadog integration
+        // Check for datadog API key ARN in different sources
+        const resolvedDatadogApiKeyArn = datadogApiKeyArn ||
+            process.env.DATADOG_API_KEY_ARN ||
+            process.env.CDK_ENV_DATADOG_API_KEY_ARN;
+        // Add Datadog integration if API key is available
+        if (resolvedDatadogApiKeyArn) {
+            // Add Datadog Node.js layer
+            const datadogNodeLayer = lambda.LayerVersion.fromLayerVersionArn(this, "DatadogNodeLayer", `arn:aws:lambda:${Stack.of(this).region}:464622532012:layer:Datadog-Node20-x:${CDK.DATADOG.LAYER.NODE}`);
+            resolvedLayers.push(datadogNodeLayer);
+            // Add Datadog Extension layer
+            const datadogExtensionLayer = lambda.LayerVersion.fromLayerVersionArn(this, "DatadogExtensionLayer", `arn:aws:lambda:${Stack.of(this).region}:464622532012:layer:Datadog-Extension:${CDK.DATADOG.LAYER.EXTENSION}`);
+            resolvedLayers.push(datadogExtensionLayer);
+            // Set Datadog environment variables
+            Object.assign(environment, {
+                DD_API_KEY_SECRET_ARN: resolvedDatadogApiKeyArn,
+                DD_ENV: process.env.PROJECT_ENV || "",
+                DD_SERVICE: process.env.PROJECT_SERVICE || "",
+                DD_SITE: CDK.DATADOG.SITE,
+                DD_TAGS: `${CDK.TAG.SPONSOR}:${process.env.PROJECT_SPONSOR || ""}`,
+            });
+        }
+        // Configure ParamsAndSecrets layer
+        let resolvedParamsAndSecrets = undefined;
+        if (paramsAndSecrets !== false) {
+            if (paramsAndSecrets instanceof lambda.ParamsAndSecretsLayerVersion) {
+                resolvedParamsAndSecrets = paramsAndSecrets;
+            }
+            else {
+                // Create default ParamsAndSecrets layer
+                resolvedParamsAndSecrets =
+                    lambda.ParamsAndSecretsLayerVersion.fromVersion(lambda.ParamsAndSecretsVersions.V1_0_103, {
+                        cacheSize: paramsAndSecretsOptions?.cacheSize,
+                        logLevel: paramsAndSecretsOptions?.logLevel ||
+                            lambda.ParamsAndSecretsLogLevel.WARN,
+                        parameterStoreTtl: paramsAndSecretsOptions?.parameterStoreTtl,
+                        secretsManagerTtl: paramsAndSecretsOptions?.secretsManagerTtl,
+                    });
+            }
+        }
+        // Process secrets environment variables
+        const secretsEnvironment = Object.entries(envSecrets).reduce((acc, [key, secret]) => ({
+            ...acc,
+            [`SECRET_${key}`]: secret.secretName,
+        }), {});
+        // Process JaypieEnvSecret array
+        const jaypieSecretsEnvironment = secrets.reduce((acc, secret) => {
+            if (secret.envKey) {
+                return {
+                    ...acc,
+                    [`SECRET_${secret.envKey}`]: secret.secretName,
+                };
+            }
+            return acc;
+        }, {});
+        // Create Lambda Function
+        this._lambda = new lambda.Function(this, "Function", {
+            code: this._code,
+            environment: {
+                ...environment,
+                ...secretsEnvironment,
+                ...jaypieSecretsEnvironment,
+            },
+            handler,
+            layers: resolvedLayers,
+            logRetention,
+            memorySize,
+            paramsAndSecrets: resolvedParamsAndSecrets,
+            reservedConcurrentExecutions,
+            runtime,
+            timeout: typeof timeout === "number" ? Duration.seconds(timeout) : timeout,
+        });
+        // Grant secret read permissions
+        Object.values(envSecrets).forEach((secret) => {
+            secret.grantRead(this._lambda);
+        });
+        // Grant read permissions for JaypieEnvSecrets
+        secrets.forEach((secret) => {
+            secret.grantRead(this);
+            secret.grantRead(this._lambda);
+        });
+        // Grant Datadog API key read permission if applicable
+        if (resolvedDatadogApiKeyArn) {
+            const datadogApiKey = secretsmanager.Secret.fromSecretCompleteArn(this, "DatadogApiKeyGrant", resolvedDatadogApiKeyArn);
+            datadogApiKey.grantRead(this._lambda);
+        }
+        if (roleTag) {
+            Tags.of(this._lambda).add(CDK.TAG.ROLE, roleTag);
+        }
+        if (vendorTag) {
+            Tags.of(this._lambda).add(CDK.TAG.VENDOR, vendorTag);
+        }
+    }
+    // Public accessors
+    get lambda() {
+        return this._lambda;
+    }
+    get code() {
+        return this._code;
+    }
+    // IFunction implementation
+    get functionArn() {
+        return this._lambda.functionArn;
+    }
+    get functionName() {
+        return this._lambda.functionName;
+    }
+    get grantPrincipal() {
+        return this._lambda.grantPrincipal;
+    }
+    get role() {
+        return this._lambda.role;
+    }
+    get architecture() {
+        return this._lambda.architecture;
+    }
+    get connections() {
+        return this._lambda.connections;
+    }
+    get isBoundToVpc() {
+        return this._lambda.isBoundToVpc;
+    }
+    get latestVersion() {
+        return this._lambda.latestVersion;
+    }
+    get permissionsNode() {
+        return this._lambda.permissionsNode;
+    }
+    get resourceArnsForGrantInvoke() {
+        return this._lambda.resourceArnsForGrantInvoke;
+    }
+    addEventSource(source) {
+        this._lambda.addEventSource(source);
+    }
+    addEventSourceMapping(id, options) {
+        return this._lambda.addEventSourceMapping(id, options);
+    }
+    addFunctionUrl(options) {
+        return this._lambda.addFunctionUrl(options);
+    }
+    addPermission(id, permission) {
+        this._lambda.addPermission(id, permission);
+    }
+    addToRolePolicy(statement) {
+        this._lambda.addToRolePolicy(statement);
+    }
+    configureAsyncInvoke(options) {
+        this._lambda.configureAsyncInvoke(options);
+    }
+    grantInvoke(grantee) {
+        return this._lambda.grantInvoke(grantee);
+    }
+    grantInvokeCompositePrincipal(compositePrincipal) {
+        return this._lambda.grantInvokeCompositePrincipal(compositePrincipal);
+    }
+    grantInvokeUrl(grantee) {
+        return this._lambda.grantInvokeUrl(grantee);
+    }
+    metric(metricName, props) {
+        return this._lambda.metric(metricName, props);
+    }
+    metricDuration(props) {
+        return this._lambda.metricDuration(props);
+    }
+    metricErrors(props) {
+        return this._lambda.metricErrors(props);
+    }
+    metricInvocations(props) {
+        return this._lambda.metricInvocations(props);
+    }
+    metricThrottles(props) {
+        return this._lambda.metricThrottles(props);
+    }
+    // Additional IFunction implementation
+    grantInvokeLatestVersion(grantee) {
+        return this._lambda.grantInvokeLatestVersion(grantee);
+    }
+    grantInvokeVersion(grantee, version) {
+        return this._lambda.grantInvokeVersion(grantee, version);
+    }
+    get env() {
+        return {
+            account: Stack.of(this).account,
+            region: Stack.of(this).region,
+        };
+    }
+    get stack() {
+        return this._lambda.stack;
+    }
+    applyRemovalPolicy(policy) {
+        this._lambda.applyRemovalPolicy(policy);
+    }
+}
+
+class JaypieQueuedLambda extends Construct {
+    constructor(scope, id, props) {
+        super(scope, id);
+        const { batchSize = 1, code, environment = {}, envSecrets = {}, fifo = true, handler = "index.handler", layers = [], logRetention = CDK.LAMBDA.LOG_RETENTION, memorySize = CDK.LAMBDA.MEMORY_SIZE, paramsAndSecrets, reservedConcurrentExecutions, roleTag, runtime = lambda.Runtime.NODEJS_20_X, secrets = [], timeout = Duration.seconds(CDK.DURATION.LAMBDA_WORKER), vendorTag, visibilityTimeout = Duration.seconds(CDK.DURATION.LAMBDA_WORKER), } = props;
+        // Create SQS Queue
+        this._queue = new sqs.Queue(this, "Queue", {
+            fifo,
+            visibilityTimeout: typeof visibilityTimeout === "number"
+                ? Duration.seconds(visibilityTimeout)
+                : visibilityTimeout,
+        });
+        if (roleTag) {
+            Tags.of(this._queue).add(CDK.TAG.ROLE, roleTag);
+        }
+        if (vendorTag) {
+            Tags.of(this._queue).add(CDK.TAG.VENDOR, vendorTag);
+        }
+        // Create Lambda with JaypieLambda
+        this._lambdaConstruct = new JaypieLambda(this, "Function", {
+            code,
+            environment: {
+                ...environment,
+                CDK_ENV_QUEUE_URL: this._queue.queueUrl,
+            },
+            envSecrets,
+            handler,
+            layers,
+            logRetention,
+            memorySize,
+            paramsAndSecrets,
+            reservedConcurrentExecutions,
+            roleTag,
+            runtime,
+            secrets,
+            timeout,
+            vendorTag,
+        });
+        // Set up queue and lambda integration
+        this._queue.grantConsumeMessages(this._lambdaConstruct);
+        this._queue.grantSendMessages(this._lambdaConstruct);
+        this._lambdaConstruct.addEventSource(new lambdaEventSources.SqsEventSource(this._queue, {
+            batchSize,
+        }));
+    }
+    // Public accessors
+    get queue() {
+        return this._queue;
+    }
+    get lambda() {
+        return this._lambdaConstruct.lambda;
+    }
+    get code() {
+        return this._lambdaConstruct.code;
+    }
+    // IFunction implementation
+    get functionArn() {
+        return this._lambdaConstruct.functionArn;
+    }
+    get functionName() {
+        return this._lambdaConstruct.functionName;
+    }
+    get grantPrincipal() {
+        return this._lambdaConstruct.grantPrincipal;
+    }
+    get role() {
+        return this._lambdaConstruct.role;
+    }
+    get architecture() {
+        return this._lambdaConstruct.architecture;
+    }
+    get connections() {
+        return this._lambdaConstruct.connections;
+    }
+    get isBoundToVpc() {
+        return this._lambdaConstruct.isBoundToVpc;
+    }
+    get latestVersion() {
+        return this._lambdaConstruct.latestVersion;
+    }
+    get permissionsNode() {
+        return this._lambdaConstruct.permissionsNode;
+    }
+    get resourceArnsForGrantInvoke() {
+        return this._lambdaConstruct.resourceArnsForGrantInvoke;
+    }
+    addEventSource(source) {
+        this._lambdaConstruct.addEventSource(source);
+    }
+    addEventSourceMapping(id, options) {
+        return this._lambdaConstruct.addEventSourceMapping(id, options);
+    }
+    addFunctionUrl(options) {
+        return this._lambdaConstruct.addFunctionUrl(options);
+    }
+    addPermission(id, permission) {
+        this._lambdaConstruct.addPermission(id, permission);
+    }
+    addToRolePolicy(statement) {
+        this._lambdaConstruct.addToRolePolicy(statement);
+    }
+    configureAsyncInvoke(options) {
+        this._lambdaConstruct.configureAsyncInvoke(options);
+    }
+    grantInvoke(grantee) {
+        return this._lambdaConstruct.grantInvoke(grantee);
+    }
+    grantInvokeCompositePrincipal(compositePrincipal) {
+        return this._lambdaConstruct.grantInvokeCompositePrincipal(compositePrincipal);
+    }
+    grantInvokeUrl(grantee) {
+        return this._lambdaConstruct.grantInvokeUrl(grantee);
+    }
+    metric(metricName, props) {
+        return this._lambdaConstruct.metric(metricName, props);
+    }
+    metricDuration(props) {
+        return this._lambdaConstruct.metricDuration(props);
+    }
+    metricErrors(props) {
+        return this._lambdaConstruct.metricErrors(props);
+    }
+    metricInvocations(props) {
+        return this._lambdaConstruct.metricInvocations(props);
+    }
+    metricThrottles(props) {
+        return this._lambdaConstruct.metricThrottles(props);
+    }
+    // Additional IFunction implementation
+    grantInvokeLatestVersion(grantee) {
+        return this._lambdaConstruct.grantInvokeLatestVersion(grantee);
+    }
+    grantInvokeVersion(grantee, version) {
+        return this._lambdaConstruct.grantInvokeVersion(grantee, version);
+    }
+    get env() {
+        return {
+            account: Stack.of(this).account,
+            region: Stack.of(this).region,
+        };
+    }
+    get stack() {
+        return Stack.of(this);
+    }
+    applyRemovalPolicy(policy) {
+        this._lambdaConstruct.applyRemovalPolicy(policy);
+        this._queue.applyRemovalPolicy(policy);
+    }
+    // IQueue implementation
+    get fifo() {
+        return this._queue.fifo;
+    }
+    get queueArn() {
+        return this._queue.queueArn;
+    }
+    get queueName() {
+        return this._queue.queueName;
+    }
+    get queueUrl() {
+        return this._queue.queueUrl;
+    }
+    get encryptionMasterKey() {
+        return this._queue.encryptionMasterKey;
+    }
+    addToResourcePolicy(statement) {
+        return this._queue.addToResourcePolicy(statement);
+    }
+    grant(grantee, ...actions) {
+        return this._queue.grant(grantee, ...actions);
+    }
+    grantConsumeMessages(grantee) {
+        return this._queue.grantConsumeMessages(grantee);
+    }
+    grantPurge(grantee) {
+        return this._queue.grantPurge(grantee);
+    }
+    grantSendMessages(grantee) {
+        return this._queue.grantSendMessages(grantee);
+    }
+    // Queue metrics
+    metricApproximateAgeOfOldestMessage(props) {
+        return this._queue.metricApproximateAgeOfOldestMessage(props);
+    }
+    metricApproximateNumberOfMessagesDelayed(props) {
+        return this._queue.metricApproximateNumberOfMessagesDelayed(props);
+    }
+    metricApproximateNumberOfMessagesNotVisible(props) {
+        return this._queue.metricApproximateNumberOfMessagesNotVisible(props);
+    }
+    metricApproximateNumberOfMessagesVisible(props) {
+        return this._queue.metricApproximateNumberOfMessagesVisible(props);
+    }
+    metricNumberOfEmptyReceives(props) {
+        return this._queue.metricNumberOfEmptyReceives(props);
+    }
+    metricNumberOfMessagesDeleted(props) {
+        return this._queue.metricNumberOfMessagesDeleted(props);
+    }
+    metricNumberOfMessagesReceived(props) {
+        return this._queue.metricNumberOfMessagesReceived(props);
+    }
+    metricNumberOfMessagesSent(props) {
+        return this._queue.metricNumberOfMessagesSent(props);
+    }
+    metricSentMessageSize(props) {
+        return this._queue.metricSentMessageSize(props);
+    }
+}
+
+class JaypieBucketQueuedLambda extends JaypieQueuedLambda {
+    constructor(scope, id, props) {
+        super(scope, id, props);
+        const { bucketName, roleTag, vendorTag, bucketOptions = {} } = props;
+        // Create S3 Bucket
+        this._bucket = new s3.Bucket(this, "Bucket", {
+            bucketName: bucketOptions.bucketName || bucketName,
+            removalPolicy: bucketOptions.removalPolicy || RemovalPolicy.RETAIN,
+            ...bucketOptions,
+        });
+        // Add tags to bucket
+        if (roleTag) {
+            Tags.of(this._bucket).add(CDK.TAG.ROLE, roleTag);
+        }
+        if (vendorTag) {
+            Tags.of(this._bucket).add(CDK.TAG.VENDOR, vendorTag);
+        }
+        // Add an event notification from the bucket to the queue
+        this._bucket.addEventNotification(s3.EventType.OBJECT_CREATED, new s3n.SqsDestination(this.queue));
+        // Grant the lambda access to the bucket
+        this._bucket.grantReadWrite(this);
+        // Add environment variable for bucket name
+        this.lambda.addEnvironment("CDK_ENV_BUCKET_NAME", this._bucket.bucketName);
+    }
+    // Public accessors
+    get bucket() {
+        return this._bucket;
+    }
+    // IBucket implementation
+    get bucketArn() {
+        return this._bucket.bucketArn;
+    }
+    get bucketDomainName() {
+        return this._bucket.bucketDomainName;
+    }
+    get bucketDualStackDomainName() {
+        return this._bucket.bucketDualStackDomainName;
+    }
+    get bucketName() {
+        return this._bucket.bucketName;
+    }
+    get bucketRegionalDomainName() {
+        return this._bucket.bucketRegionalDomainName;
+    }
+    get bucketWebsiteDomainName() {
+        return this._bucket.bucketWebsiteDomainName;
+    }
+    get bucketWebsiteUrl() {
+        return this._bucket.bucketWebsiteUrl;
+    }
+    get encryptionKey() {
+        return this._bucket.encryptionKey;
+    }
+    get isWebsite() {
+        return this._bucket.isWebsite || false;
+    }
+    get policy() {
+        return this._bucket.policy;
+    }
+    addEventNotification(event, dest, filters) {
+        this._bucket.addEventNotification(event, dest, ...filters);
+    }
+    addObjectCreatedNotification(dest, ...filters) {
+        this._bucket.addObjectCreatedNotification(dest, ...filters);
+    }
+    addObjectRemovedNotification(dest, ...filters) {
+        this._bucket.addObjectRemovedNotification(dest, ...filters);
+    }
+    addToResourcePolicy(permission) {
+        return this._bucket.addToResourcePolicy(permission);
+    }
+    arnForObjects(objectKeyPattern) {
+        return this._bucket.arnForObjects(objectKeyPattern);
+    }
+    enableEventBridgeNotification() {
+        this._bucket.enableEventBridgeNotification();
+    }
+    grant(grantee, ...actions) {
+        return this._bucket.grant(grantee, ...actions);
+    }
+    grantDelete(grantee, objectsKeyPattern) {
+        return this._bucket.grantDelete(grantee, objectsKeyPattern);
+    }
+    grantPublicAccess(keyPrefix, ...allowedActions) {
+        return this._bucket.grantPublicAccess(keyPrefix, ...allowedActions);
+    }
+    grantPut(grantee, objectsKeyPattern) {
+        return this._bucket.grantPut(grantee, objectsKeyPattern);
+    }
+    grantPutAcl(grantee, objectsKeyPattern) {
+        return this._bucket.grantPutAcl(grantee, objectsKeyPattern);
+    }
+    grantRead(grantee, objectsKeyPattern) {
+        return this._bucket.grantRead(grantee, objectsKeyPattern);
+    }
+    grantReadWrite(grantee, objectsKeyPattern) {
+        return this._bucket.grantReadWrite(grantee, objectsKeyPattern);
+    }
+    grantWrite(grantee, objectsKeyPattern) {
+        return this._bucket.grantWrite(grantee, objectsKeyPattern);
+    }
+    onCloudTrailEvent(id, options) {
+        return this._bucket.onCloudTrailEvent(id, options);
+    }
+    onCloudTrailPutObject(id, options) {
+        return this._bucket.onCloudTrailPutObject(id, options);
+    }
+    onCloudTrailWriteObject(id, options) {
+        return this._bucket.onCloudTrailWriteObject(id, options);
+    }
+    s3UrlForObject(key) {
+        return this._bucket.s3UrlForObject(key);
+    }
+    transferAccelerationUrlForObject(key, options) {
+        return this._bucket.transferAccelerationUrlForObject(key, options);
+    }
+    urlForObject(key) {
+        return this._bucket.urlForObject(key);
+    }
+    virtualHostedUrlForObject(key, options) {
+        return this._bucket.virtualHostedUrlForObject(key, options);
+    }
+    // Bucket metrics
+    metricAllRequests(props) {
+        return this._bucket.metricAllRequests(props);
+    }
+    metricBucketSizeBytes(props) {
+        return this._bucket.metricBucketSizeBytes(props);
+    }
+    metricDeleteRequests(props) {
+        return this._bucket.metricDeleteRequests(props);
+    }
+    metricDownloadBytes(props) {
+        return this._bucket.metricDownloadBytes(props);
+    }
+    metricFirstByteLatency(props) {
+        return this._bucket.metricFirstByteLatency(props);
+    }
+    metricGetRequests(props) {
+        return this._bucket.metricGetRequests(props);
+    }
+    metricHeadRequests(props) {
+        return this._bucket.metricHeadRequests(props);
+    }
+    metricHttpRequests(props) {
+        return this._bucket.metricHttpRequests(props);
+    }
+    metricListRequests(props) {
+        return this._bucket.metricListRequests(props);
+    }
+    metricNumberOfObjects(props) {
+        return this._bucket.metricNumberOfObjects(props);
+    }
+    metricPostRequests(props) {
+        return this._bucket.metricPostRequests(props);
+    }
+    metricPutRequests(props) {
+        return this._bucket.metricPutRequests(props);
+    }
+    metricSelectRequests(props) {
+        return this._bucket.metricSelectRequests(props);
+    }
+    metricSelectScannedBytes(props) {
+        return this._bucket.metricSelectScannedBytes(props);
+    }
+    metricUploadBytes(props) {
+        return this._bucket.metricUploadBytes(props);
+    }
+    metricSelectReturnedBytes(props) {
+        return this._bucket.metricSelectReturnedBytes(props);
+    }
+    // Override applyRemovalPolicy to apply to all resources
+    applyRemovalPolicy(policy) {
+        super.applyRemovalPolicy(policy);
+        this._bucket.applyRemovalPolicy(policy);
+    }
+}
+
 // It is a consumer if the environment is ephemeral
 function checkEnvIsConsumer(env = process.env) {
     return (env.PROJECT_ENV === CDK.ENV.PERSONAL ||
@@ -214,242 +805,6 @@ class JaypieOpenAiSecret extends JaypieEnvSecret {
     }
 }
 
-class JaypieQueuedLambda extends Construct {
-    constructor(scope, id, props) {
-        super(scope, id);
-        const { batchSize = 1, code, environment = {}, envSecrets = {}, fifo = true, handler = "index.handler", layers = [], logRetention = CDK.LAMBDA.LOG_RETENTION, memorySize = CDK.LAMBDA.MEMORY_SIZE, paramsAndSecrets, reservedConcurrentExecutions, roleTag, runtime = lambda.Runtime.NODEJS_20_X, secrets = [], timeout = Duration.seconds(CDK.DURATION.LAMBDA_WORKER), vendorTag, visibilityTimeout = Duration.seconds(CDK.DURATION.LAMBDA_WORKER), } = props;
-        this._code = typeof code === "string" ? lambda.Code.fromAsset(code) : code;
-        // Create SQS Queue
-        this._queue = new sqs.Queue(this, "Queue", {
-            fifo,
-            visibilityTimeout: typeof visibilityTimeout === "number"
-                ? Duration.seconds(visibilityTimeout)
-                : visibilityTimeout,
-        });
-        if (roleTag) {
-            Tags.of(this._queue).add(CDK.TAG.ROLE, roleTag);
-        }
-        if (vendorTag) {
-            Tags.of(this._queue).add(CDK.TAG.VENDOR, vendorTag);
-        }
-        // Process secrets environment variables
-        const secretsEnvironment = Object.entries(envSecrets).reduce((acc, [key, secret]) => ({
-            ...acc,
-            [`SECRET_${key}`]: secret.secretName,
-        }), {});
-        // Process JaypieEnvSecret array
-        const jaypieSecretsEnvironment = secrets.reduce((acc, secret) => {
-            if (secret.envKey) {
-                return {
-                    ...acc,
-                    [`SECRET_${secret.envKey}`]: secret.secretName,
-                };
-            }
-            return acc;
-        }, {});
-        // Create Lambda Function
-        this._lambda = new lambda.Function(this, "Function", {
-            code: this._code,
-            environment: {
-                CDK_ENV_QUEUE_URL: this._queue.queueUrl,
-                ...environment,
-                ...secretsEnvironment,
-                ...jaypieSecretsEnvironment,
-            },
-            handler,
-            layers,
-            logRetention,
-            memorySize,
-            paramsAndSecrets,
-            reservedConcurrentExecutions,
-            runtime,
-            timeout: typeof timeout === "number" ? Duration.seconds(timeout) : timeout,
-        });
-        // Grant secret read permissions
-        Object.values(envSecrets).forEach((secret) => {
-            secret.grantRead(this._lambda);
-        });
-        // Grant read permissions for JaypieEnvSecrets
-        secrets.forEach((secret) => {
-            secret.grantRead(this);
-            secret.grantRead(this._lambda);
-        });
-        this._queue.grantConsumeMessages(this._lambda);
-        this._queue.grantSendMessages(this._lambda);
-        this._lambda.addEventSource(new lambdaEventSources.SqsEventSource(this._queue, {
-            batchSize,
-        }));
-        if (roleTag) {
-            Tags.of(this._lambda).add(CDK.TAG.ROLE, roleTag);
-        }
-        if (vendorTag) {
-            Tags.of(this._lambda).add(CDK.TAG.VENDOR, vendorTag);
-        }
-    }
-    // Public accessors
-    get queue() {
-        return this._queue;
-    }
-    get lambda() {
-        return this._lambda;
-    }
-    get code() {
-        return this._code;
-    }
-    // IFunction implementation
-    get functionArn() {
-        return this._lambda.functionArn;
-    }
-    get functionName() {
-        return this._lambda.functionName;
-    }
-    get grantPrincipal() {
-        return this._lambda.grantPrincipal;
-    }
-    get role() {
-        return this._lambda.role;
-    }
-    get architecture() {
-        return this._lambda.architecture;
-    }
-    get connections() {
-        return this._lambda.connections;
-    }
-    get isBoundToVpc() {
-        return this._lambda.isBoundToVpc;
-    }
-    get latestVersion() {
-        return this._lambda.latestVersion;
-    }
-    get permissionsNode() {
-        return this._lambda.permissionsNode;
-    }
-    get resourceArnsForGrantInvoke() {
-        return this._lambda.resourceArnsForGrantInvoke;
-    }
-    addEventSource(source) {
-        this._lambda.addEventSource(source);
-    }
-    addEventSourceMapping(id, options) {
-        return this._lambda.addEventSourceMapping(id, options);
-    }
-    addFunctionUrl(options) {
-        return this._lambda.addFunctionUrl(options);
-    }
-    addPermission(id, permission) {
-        this._lambda.addPermission(id, permission);
-    }
-    addToRolePolicy(statement) {
-        this._lambda.addToRolePolicy(statement);
-    }
-    configureAsyncInvoke(options) {
-        this._lambda.configureAsyncInvoke(options);
-    }
-    grantInvoke(grantee) {
-        return this._lambda.grantInvoke(grantee);
-    }
-    grantInvokeCompositePrincipal(compositePrincipal) {
-        return this._lambda.grantInvokeCompositePrincipal(compositePrincipal);
-    }
-    grantInvokeUrl(grantee) {
-        return this._lambda.grantInvokeUrl(grantee);
-    }
-    metric(metricName, props) {
-        return this._lambda.metric(metricName, props);
-    }
-    metricDuration(props) {
-        return this._lambda.metricDuration(props);
-    }
-    metricErrors(props) {
-        return this._lambda.metricErrors(props);
-    }
-    metricInvocations(props) {
-        return this._lambda.metricInvocations(props);
-    }
-    metricThrottles(props) {
-        return this._lambda.metricThrottles(props);
-    }
-    // Additional IFunction implementation
-    grantInvokeLatestVersion(grantee) {
-        return this._lambda.grantInvokeLatestVersion(grantee);
-    }
-    grantInvokeVersion(grantee, version) {
-        return this._lambda.grantInvokeVersion(grantee, version);
-    }
-    get env() {
-        return {
-            account: Stack.of(this).account,
-            region: Stack.of(this).region,
-        };
-    }
-    get stack() {
-        return this._lambda.stack;
-    }
-    applyRemovalPolicy(policy) {
-        this._lambda.applyRemovalPolicy(policy);
-        this._queue.applyRemovalPolicy(policy);
-    }
-    // IQueue implementation
-    get fifo() {
-        return this._queue.fifo;
-    }
-    get queueArn() {
-        return this._queue.queueArn;
-    }
-    get queueName() {
-        return this._queue.queueName;
-    }
-    get queueUrl() {
-        return this._queue.queueUrl;
-    }
-    get encryptionMasterKey() {
-        return this._queue.encryptionMasterKey;
-    }
-    addToResourcePolicy(statement) {
-        return this._queue.addToResourcePolicy(statement);
-    }
-    grant(grantee, ...actions) {
-        return this._queue.grant(grantee, ...actions);
-    }
-    grantConsumeMessages(grantee) {
-        return this._queue.grantConsumeMessages(grantee);
-    }
-    grantPurge(grantee) {
-        return this._queue.grantPurge(grantee);
-    }
-    grantSendMessages(grantee) {
-        return this._queue.grantSendMessages(grantee);
-    }
-    // Queue metrics
-    metricApproximateAgeOfOldestMessage(props) {
-        return this._queue.metricApproximateAgeOfOldestMessage(props);
-    }
-    metricApproximateNumberOfMessagesDelayed(props) {
-        return this._queue.metricApproximateNumberOfMessagesDelayed(props);
-    }
-    metricApproximateNumberOfMessagesNotVisible(props) {
-        return this._queue.metricApproximateNumberOfMessagesNotVisible(props);
-    }
-    metricApproximateNumberOfMessagesVisible(props) {
-        return this._queue.metricApproximateNumberOfMessagesVisible(props);
-    }
-    metricNumberOfEmptyReceives(props) {
-        return this._queue.metricNumberOfEmptyReceives(props);
-    }
-    metricNumberOfMessagesDeleted(props) {
-        return this._queue.metricNumberOfMessagesDeleted(props);
-    }
-    metricNumberOfMessagesReceived(props) {
-        return this._queue.metricNumberOfMessagesReceived(props);
-    }
-    metricNumberOfMessagesSent(props) {
-        return this._queue.metricNumberOfMessagesSent(props);
-    }
-    metricSentMessageSize(props) {
-        return this._queue.metricSentMessageSize(props);
-    }
-}
-
 /**
  * Permission set types with corresponding AWS managed policies
  */
@@ -736,5 +1091,5 @@ class JaypieTraceSigningKeySecret extends JaypieEnvSecret {
     }
 }
 
-export { JaypieEnvSecret, JaypieHostedZone, JaypieMongoDbSecret, JaypieOpenAiSecret, JaypieQueuedLambda, JaypieSsoGroups, JaypieTraceSigningKeySecret, PermissionSetType };
+export { JaypieBucketQueuedLambda, JaypieEnvSecret, JaypieHostedZone, JaypieLambda, JaypieMongoDbSecret, JaypieOpenAiSecret, JaypieQueuedLambda, JaypieSsoGroups, JaypieTraceSigningKeySecret, PermissionSetType };
 //# sourceMappingURL=index.js.map