@jaypie/constructs 1.1.37 → 1.1.38

package/dist/cjs/JaypieLambda.d.ts

@@ -7,17 +7,32 @@ import * as ec2 from "aws-cdk-lib/aws-ec2";
 import * as secretsmanager from "aws-cdk-lib/aws-secretsmanager";
 import { JaypieEnvSecret } from "./JaypieEnvSecret.js";
 export interface JaypieLambdaProps {
+    allowAllOutbound?: boolean;
+    allowPublicSubnet?: boolean;
+    architecture?: lambda.Architecture;
     code: lambda.Code | string;
+    codeSigningConfig?: lambda.ICodeSigningConfig;
     datadogApiKeyArn?: string;
+    deadLetterQueue?: import("aws-cdk-lib/aws-sqs").IQueue;
+    deadLetterQueueEnabled?: boolean;
+    deadLetterTopic?: import("aws-cdk-lib/aws-sns").ITopic;
+    description?: string;
     environment?: {
         [key: string]: string;
     };
+    environmentEncryption?: import("aws-cdk-lib/aws-kms").IKey;
     envSecrets?: {
         [key: string]: secretsmanager.ISecret;
     };
+    ephemeralStorageSize?: import("aws-cdk-lib").Size;
+    filesystem?: lambda.FileSystemConfig;
     handler: string;
+    initialPolicy?: iam.PolicyStatement[];
     layers?: lambda.ILayerVersion[];
     logRetention?: number;
+    logRetentionRole?: iam.IRole;
+    logRetentionRetryOptions?: lambda.LogRetentionRetryOptions;
+    maxEventAge?: Duration;
     memorySize?: number;
     paramsAndSecrets?: lambda.ParamsAndSecretsLayerVersion | boolean;
     paramsAndSecretsOptions?: {
@@ -26,13 +41,18 @@ export interface JaypieLambdaProps {
         parameterStoreTtl?: number;
         secretsManagerTtl?: number;
     };
+    profiling?: boolean;
+    profilingGroup?: import("aws-cdk-lib/aws-codeguruprofiler").IProfilingGroup;
     provisionedConcurrentExecutions?: number;
     reservedConcurrentExecutions?: number;
+    retryAttempts?: number;
     roleTag?: string;
     runtime?: lambda.Runtime;
+    runtimeManagementMode?: lambda.RuntimeManagementMode;
     secrets?: JaypieEnvSecret[];
     securityGroups?: ec2.ISecurityGroup[];
     timeout?: Duration | number;
+    tracing?: lambda.Tracing;
     vendorTag?: string;
     vpc?: ec2.IVpc;
     vpcSubnets?: ec2.SubnetSelection;
@@ -52,6 +72,24 @@ export declare class JaypieLambda extends Construct implements lambda.IFunction
     private readonly _securityGroups?;
     private readonly _reservedConcurrentExecutions?;
     private readonly _layers;
+    private readonly _architecture;
+    private readonly _ephemeralStorageSize?;
+    private readonly _codeSigningConfig?;
+    private readonly _filesystemConfigs?;
+    private readonly _environmentEncryption?;
+    private readonly _tracing?;
+    private readonly _profiling?;
+    private readonly _profilingGroup?;
+    private readonly _logRetentionRole?;
+    private readonly _logRetentionRetryOptions?;
+    private readonly _initialPolicy?;
+    private readonly _description?;
+    private readonly _maxEventAge?;
+    private readonly _retryAttempts?;
+    private readonly _runtimeManagementMode?;
+    private readonly _allowAllOutbound?;
+    private readonly _allowPublicSubnet?;
+    private readonly _deadLetterQueueEnabled?;
     constructor(scope: Construct, id: string, props: JaypieLambdaProps);
     get lambda(): lambda.Function;
     get provisioned(): lambda.Alias | undefined;
@@ -112,7 +150,7 @@ export declare class JaypieLambda extends Construct implements lambda.IFunction
     get retryAttempts(): number | undefined;
     get reservedConcurrentExecutions(): number | undefined;
     get description(): string | undefined;
-    get initialPolicy(): iam.PolicyDocument[] | undefined;
+    get initialPolicy(): iam.PolicyStatement[] | undefined;
     get logRetentionRole(): iam.IRole | undefined;
     get logRetentionRetryOptions(): lambda.LogRetentionRetryOptions | undefined;
     get tracing(): lambda.Tracing | undefined;
@@ -131,4 +169,6 @@ export declare class JaypieLambda extends Construct implements lambda.IFunction
     get allowAllOutbound(): boolean | undefined;
     get allowPublicSubnet(): boolean | undefined;
     get canCreateLambdaLogGroup(): boolean;
+    get canCreatePermissions(): boolean;
+    get deadLetterQueueEnabled(): boolean | undefined;
 }

package/dist/cjs/index.cjs

@@ -323,7 +323,7 @@ class JaypieAppStack extends JaypieStack {
 class JaypieLambda extends constructs.Construct {
     constructor(scope, id, props) {
         super(scope, id);
-        const { code, datadogApiKeyArn, environment: initialEnvironment = {}, envSecrets = {}, handler = "index.handler", layers = [], logRetention = cdk.CDK.LAMBDA.LOG_RETENTION, memorySize = cdk.CDK.LAMBDA.MEMORY_SIZE, paramsAndSecrets, paramsAndSecretsOptions, provisionedConcurrentExecutions, reservedConcurrentExecutions, roleTag = cdk.CDK.ROLE.PROCESSING, runtime = lambda__namespace.Runtime.NODEJS_22_X, secrets = [], securityGroups, timeout = cdk$1.Duration.seconds(cdk.CDK.DURATION.LAMBDA_WORKER), vendorTag, vpc, vpcSubnets, } = props;
+        const { allowAllOutbound, allowPublicSubnet, architecture = lambda__namespace.Architecture.X86_64, code, codeSigningConfig, datadogApiKeyArn, deadLetterQueue, deadLetterQueueEnabled, deadLetterTopic, description, environment: initialEnvironment = {}, environmentEncryption, envSecrets = {}, ephemeralStorageSize, filesystem, handler = "index.handler", initialPolicy, layers = [], logRetention = cdk.CDK.LAMBDA.LOG_RETENTION, logRetentionRole, logRetentionRetryOptions, maxEventAge, memorySize = cdk.CDK.LAMBDA.MEMORY_SIZE, paramsAndSecrets, paramsAndSecretsOptions, profiling, profilingGroup, provisionedConcurrentExecutions, reservedConcurrentExecutions, retryAttempts, roleTag = cdk.CDK.ROLE.PROCESSING, runtime = lambda__namespace.Runtime.NODEJS_22_X, runtimeManagementMode, secrets = [], securityGroups, timeout = cdk$1.Duration.seconds(cdk.CDK.DURATION.LAMBDA_WORKER), tracing, vendorTag, vpc, vpcSubnets, } = props;
         // Create a mutable copy of the environment variables
         let environment = { ...initialEnvironment };
         // Default environment values
@@ -437,21 +437,41 @@ class JaypieLambda extends constructs.Construct {
         }, {});
         // Create Lambda Function
         this._lambda = new lambda__namespace.Function(this, "Function", {
+            allowAllOutbound,
+            allowPublicSubnet,
+            architecture,
             code: this._code,
+            codeSigningConfig,
+            deadLetterQueue,
+            deadLetterQueueEnabled,
+            deadLetterTopic,
+            description,
             environment: {
                 ...environment,
                 ...secretsEnvironment,
                 ...jaypieSecretsEnvironment,
             },
+            environmentEncryption,
+            ephemeralStorageSize,
+            filesystem: filesystem ? { config: filesystem } : undefined,
             handler,
+            initialPolicy,
             layers: resolvedLayers,
             logRetention,
+            logRetentionRole,
+            logRetentionRetryOptions,
+            maxEventAge,
             memorySize,
             paramsAndSecrets: resolvedParamsAndSecrets,
+            profiling,
+            profilingGroup,
             reservedConcurrentExecutions,
+            retryAttempts,
             runtime,
+            runtimeManagementMode,
             securityGroups,
             timeout: typeof timeout === "number" ? cdk$1.Duration.seconds(timeout) : timeout,
+            tracing,
             vpc,
             vpcSubnets,
             // Enable auto-publishing of versions when using provisioned concurrency
@@ -511,6 +531,24 @@ class JaypieLambda extends constructs.Construct {
         this._securityGroups = securityGroups;
         this._reservedConcurrentExecutions = reservedConcurrentExecutions;
         this._layers = resolvedLayers;
+        this._architecture = architecture;
+        this._ephemeralStorageSize = ephemeralStorageSize?.toMebibytes();
+        this._codeSigningConfig = codeSigningConfig;
+        this._filesystemConfigs = filesystem ? [filesystem] : undefined;
+        this._environmentEncryption = environmentEncryption;
+        this._tracing = tracing;
+        this._profiling = profiling;
+        this._profilingGroup = profilingGroup;
+        this._logRetentionRole = logRetentionRole;
+        this._logRetentionRetryOptions = logRetentionRetryOptions;
+        this._initialPolicy = initialPolicy;
+        this._description = description;
+        this._maxEventAge = maxEventAge;
+        this._retryAttempts = retryAttempts;
+        this._runtimeManagementMode = runtimeManagementMode;
+        this._allowAllOutbound = allowAllOutbound;
+        this._allowPublicSubnet = allowPublicSubnet;
+        this._deadLetterQueueEnabled = deadLetterQueueEnabled;
         // Assign _reference based on provisioned state
         this._reference =
             this._provisioned !== undefined ? this._provisioned : this._lambda;
@@ -690,52 +728,52 @@ class JaypieLambda extends constructs.Construct {
         return this._layers;
     }
     get maxEventAge() {
-        return undefined;
+        return this._maxEventAge;
     }
     get retryAttempts() {
-        return undefined;
+        return this._retryAttempts;
     }
     get reservedConcurrentExecutions() {
         return this._reservedConcurrentExecutions;
     }
     get description() {
-        return undefined;
+        return this._description;
     }
     get initialPolicy() {
-        return undefined;
+        return this._initialPolicy;
     }
     get logRetentionRole() {
-        return undefined;
+        return this._logRetentionRole;
     }
     get logRetentionRetryOptions() {
-        return undefined;
+        return this._logRetentionRetryOptions;
     }
     get tracing() {
-        return undefined;
+        return this._tracing;
     }
     get profiling() {
-        return undefined;
+        return this._profiling;
     }
     get profilingGroup() {
-        return undefined;
+        return this._profilingGroup;
     }
     get environmentEncryption() {
-        return undefined;
+        return this._environmentEncryption;
     }
     get codeSigningConfig() {
-        return undefined;
+        return this._codeSigningConfig;
     }
     get filesystemConfig() {
-        return undefined;
+        return this._filesystemConfigs?.[0];
     }
     get filesystemConfigs() {
-        return undefined;
+        return this._filesystemConfigs;
     }
     get ephemeralStorageSize() {
-        return undefined;
+        return this._ephemeralStorageSize;
     }
     get runtimeManagementMode() {
-        return undefined;
+        return this._runtimeManagementMode;
     }
     get architectureLabel() {
         return this._lambda.architecture.name;
@@ -750,14 +788,20 @@ class JaypieLambda extends constructs.Construct {
         return this._securityGroups;
     }
     get allowAllOutbound() {
-        return undefined;
+        return this._allowAllOutbound;
     }
     get allowPublicSubnet() {
-        return undefined;
+        return this._allowPublicSubnet;
     }
     get canCreateLambdaLogGroup() {
         return true;
     }
+    get canCreatePermissions() {
+        return true;
+    }
+    get deadLetterQueueEnabled() {
+        return this._lambda.deadLetterQueue !== undefined || this._lambda.deadLetterTopic !== undefined;
+    }
 }
 
 class JaypieQueuedLambda extends constructs.Construct {