@jaypie/constructs 1.1.36-beta.2 → 1.1.37

package/dist/esm/JaypieEnvSecret.d.ts

@@ -1,5 +1,6 @@
 import { Construct } from "constructs";
 import { SecretValue, RemovalPolicy, Stack } from "aws-cdk-lib";
+import * as secretsmanager from "aws-cdk-lib/aws-secretsmanager";
 import { ISecret, ISecretAttachmentTarget, RotationSchedule, RotationScheduleOptions } from "aws-cdk-lib/aws-secretsmanager";
 import { IKey } from "aws-cdk-lib/aws-kms";
 import { Grant, IGrantable, PolicyStatement, AddToResourcePolicyResult } from "aws-cdk-lib/aws-iam";
@@ -7,6 +8,7 @@ export interface JaypieEnvSecretProps {
     consumer?: boolean;
     envKey?: string;
     export?: string;
+    generateSecretString?: secretsmanager.SecretStringGenerator;
     provider?: boolean;
     roleTag?: string;
     vendorTag?: string;

package/dist/esm/JaypieLambda.d.ts

@@ -3,6 +3,7 @@ import { Duration, Stack, RemovalPolicy } from "aws-cdk-lib";
 import * as lambda from "aws-cdk-lib/aws-lambda";
 import * as iam from "aws-cdk-lib/aws-iam";
 import * as cloudwatch from "aws-cdk-lib/aws-cloudwatch";
+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 {
@@ -30,18 +31,32 @@ export interface JaypieLambdaProps {
     roleTag?: string;
     runtime?: lambda.Runtime;
     secrets?: JaypieEnvSecret[];
+    securityGroups?: ec2.ISecurityGroup[];
     timeout?: Duration | number;
     vendorTag?: string;
+    vpc?: ec2.IVpc;
+    vpcSubnets?: ec2.SubnetSelection;
 }
 export declare class JaypieLambda extends Construct implements lambda.IFunction {
     private readonly _lambda;
     private readonly _provisioned?;
     private readonly _code;
     private readonly _reference;
+    private readonly _handler;
+    private readonly _memorySize;
+    private readonly _timeout;
+    private readonly _runtime;
+    private readonly _environment;
+    private readonly _vpc?;
+    private readonly _vpcSubnets?;
+    private readonly _securityGroups?;
+    private readonly _reservedConcurrentExecutions?;
+    private readonly _layers;
     constructor(scope: Construct, id: string, props: JaypieLambdaProps);
     get lambda(): lambda.Function;
     get provisioned(): lambda.Alias | undefined;
     get code(): lambda.Code;
+    get reference(): lambda.IFunction;
     get functionArn(): string;
     get functionName(): string;
     get grantPrincipal(): iam.IPrincipal;
@@ -75,4 +90,45 @@ export declare class JaypieLambda extends Construct implements lambda.IFunction
     };
     get stack(): Stack;
     applyRemovalPolicy(policy: RemovalPolicy): void;
+    get currentVersion(): lambda.Version;
+    get deadLetterQueue(): import("aws-cdk-lib/aws-sqs").IQueue | undefined;
+    get deadLetterTopic(): import("aws-cdk-lib/aws-sns").ITopic | undefined;
+    get logGroup(): import("aws-cdk-lib/aws-logs").ILogGroup;
+    get runtime(): lambda.Runtime;
+    get timeout(): Duration | undefined;
+    addAlias(aliasName: string, options?: lambda.AliasOptions): lambda.Alias;
+    addLayers(...layers: lambda.ILayerVersion[]): void;
+    invalidateVersionBasedOn(x: string): void;
+    metricConcurrentExecutions(props?: cloudwatch.MetricOptions): cloudwatch.Metric;
+    metricUnreservedConcurrentExecutions(props?: cloudwatch.MetricOptions): cloudwatch.Metric;
+    addVersion(name: string, codeSha256?: string, description?: string, provisionedExecutions?: number, asyncInvokeConfig?: lambda.EventInvokeConfigOptions): lambda.Version;
+    get memorySize(): number | undefined;
+    get handler(): string;
+    get environment(): {
+        [key: string]: string;
+    } | undefined;
+    get layers(): lambda.ILayerVersion[] | undefined;
+    get maxEventAge(): Duration | undefined;
+    get retryAttempts(): number | undefined;
+    get reservedConcurrentExecutions(): number | undefined;
+    get description(): string | undefined;
+    get initialPolicy(): iam.PolicyDocument[] | undefined;
+    get logRetentionRole(): iam.IRole | undefined;
+    get logRetentionRetryOptions(): lambda.LogRetentionRetryOptions | undefined;
+    get tracing(): lambda.Tracing | undefined;
+    get profiling(): boolean | undefined;
+    get profilingGroup(): import("aws-cdk-lib/aws-codeguruprofiler").IProfilingGroup | undefined;
+    get environmentEncryption(): import("aws-cdk-lib/aws-kms").IKey | undefined;
+    get codeSigningConfig(): lambda.ICodeSigningConfig | undefined;
+    get filesystemConfig(): lambda.FileSystemConfig | undefined;
+    get filesystemConfigs(): lambda.FileSystemConfig[] | undefined;
+    get ephemeralStorageSize(): number | undefined;
+    get runtimeManagementMode(): lambda.RuntimeManagementMode | undefined;
+    get architectureLabel(): string;
+    get vpc(): ec2.IVpc | undefined;
+    get vpcSubnets(): ec2.SubnetSelection | undefined;
+    get securityGroups(): ec2.ISecurityGroup[] | undefined;
+    get allowAllOutbound(): boolean | undefined;
+    get allowPublicSubnet(): boolean | undefined;
+    get canCreateLambdaLogGroup(): boolean;
 }

package/dist/esm/index.js

@@ -12,6 +12,7 @@ import * as s3n from 'aws-cdk-lib/aws-s3-notifications';
 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 cloudwatch from 'aws-cdk-lib/aws-cloudwatch';
 import * as secretsmanager from 'aws-cdk-lib/aws-secretsmanager';
 import { ServicePrincipal, Role, FederatedPrincipal, PolicyStatement, Effect } from 'aws-cdk-lib/aws-iam';
 import { LogGroup, RetentionDays, FilterPattern } from 'aws-cdk-lib/aws-logs';
@@ -289,7 +290,7 @@ class JaypieAppStack extends JaypieStack {
 class JaypieLambda extends Construct {
     constructor(scope, id, props) {
         super(scope, id);
-        const { code, datadogApiKeyArn, environment: initialEnvironment = {}, envSecrets = {}, handler = "index.handler", layers = [], logRetention = CDK$2.LAMBDA.LOG_RETENTION, memorySize = CDK$2.LAMBDA.MEMORY_SIZE, paramsAndSecrets, paramsAndSecretsOptions, provisionedConcurrentExecutions, reservedConcurrentExecutions, roleTag = CDK$2.ROLE.PROCESSING, runtime = lambda.Runtime.NODEJS_22_X, secrets = [], timeout = Duration.seconds(CDK$2.DURATION.LAMBDA_WORKER), vendorTag, } = props;
+        const { code, datadogApiKeyArn, environment: initialEnvironment = {}, envSecrets = {}, handler = "index.handler", layers = [], logRetention = CDK$2.LAMBDA.LOG_RETENTION, memorySize = CDK$2.LAMBDA.MEMORY_SIZE, paramsAndSecrets, paramsAndSecretsOptions, provisionedConcurrentExecutions, reservedConcurrentExecutions, roleTag = CDK$2.ROLE.PROCESSING, runtime = lambda.Runtime.NODEJS_22_X, secrets = [], securityGroups, timeout = Duration.seconds(CDK$2.DURATION.LAMBDA_WORKER), vendorTag, vpc, vpcSubnets, } = props;
         // Create a mutable copy of the environment variables
         let environment = { ...initialEnvironment };
         // Default environment values
@@ -354,10 +355,14 @@ class JaypieLambda extends Construct {
             // Set Datadog environment variables
             Object.assign(environment, {
                 DD_API_KEY_SECRET_ARN: resolvedDatadogApiKeyArn,
+                DD_ENHANCED_METRICS: "true",
                 DD_ENV: process.env.PROJECT_ENV || "",
+                DD_PROFILING_ENABLED: "false",
+                DD_SERVERLESS_APPSEC_ENABLED: "false",
                 DD_SERVICE: process.env.PROJECT_SERVICE || "",
                 DD_SITE: CDK$2.DATADOG.SITE,
                 DD_TAGS: `${CDK$2.TAG.SPONSOR}:${process.env.PROJECT_SPONSOR || ""}`,
+                DD_TRACE_OTEL_ENABLED: "false",
             });
         }
         // Configure ParamsAndSecrets layer
@@ -412,7 +417,10 @@ class JaypieLambda extends Construct {
             paramsAndSecrets: resolvedParamsAndSecrets,
             reservedConcurrentExecutions,
             runtime,
+            securityGroups,
             timeout: typeof timeout === "number" ? Duration.seconds(timeout) : timeout,
+            vpc,
+            vpcSubnets,
             // Enable auto-publishing of versions when using provisioned concurrency
             currentVersionOptions: provisionedConcurrentExecutions !== undefined
                 ? {
@@ -454,6 +462,22 @@ class JaypieLambda extends Construct {
         if (vendorTag) {
             Tags.of(this._lambda).add(CDK$2.TAG.VENDOR, vendorTag);
         }
+        // Store constructor props for later access
+        this._handler = handler;
+        this._memorySize = memorySize;
+        this._timeout =
+            typeof timeout === "number" ? Duration.seconds(timeout) : timeout;
+        this._runtime = runtime;
+        this._environment = {
+            ...environment,
+            ...secretsEnvironment,
+            ...jaypieSecretsEnvironment,
+        };
+        this._vpc = vpc;
+        this._vpcSubnets = vpcSubnets;
+        this._securityGroups = securityGroups;
+        this._reservedConcurrentExecutions = reservedConcurrentExecutions;
+        this._layers = resolvedLayers;
         // Assign _reference based on provisioned state
         this._reference =
             this._provisioned !== undefined ? this._provisioned : this._lambda;
@@ -468,6 +492,9 @@ class JaypieLambda extends Construct {
     get code() {
         return this._code;
     }
+    get reference() {
+        return this._reference;
+    }
     // IFunction implementation
     get functionArn() {
         return this._reference.functionArn;
@@ -563,6 +590,141 @@ class JaypieLambda extends Construct {
     applyRemovalPolicy(policy) {
         this._reference.applyRemovalPolicy(policy);
     }
+    // Additional Lambda Function specific methods
+    get currentVersion() {
+        return this._lambda.currentVersion;
+    }
+    get deadLetterQueue() {
+        return this._lambda.deadLetterQueue;
+    }
+    get deadLetterTopic() {
+        return this._lambda.deadLetterTopic;
+    }
+    get logGroup() {
+        return this._lambda.logGroup;
+    }
+    get runtime() {
+        return this._runtime;
+    }
+    get timeout() {
+        return this._timeout;
+    }
+    addAlias(aliasName, options) {
+        return this._lambda.addAlias(aliasName, options);
+    }
+    addLayers(...layers) {
+        this._lambda.addLayers(...layers);
+    }
+    invalidateVersionBasedOn(x) {
+        this._lambda.invalidateVersionBasedOn(x);
+    }
+    metricConcurrentExecutions(props) {
+        return new cloudwatch.Metric({
+            namespace: "AWS/Lambda",
+            metricName: "ConcurrentExecutions",
+            dimensionsMap: {
+                FunctionName: this.functionName,
+            },
+            ...props,
+        });
+    }
+    metricUnreservedConcurrentExecutions(props) {
+        return new cloudwatch.Metric({
+            namespace: "AWS/Lambda",
+            metricName: "UnreservedConcurrentExecutions",
+            ...props,
+        });
+    }
+    addVersion(name, codeSha256, description, provisionedExecutions, asyncInvokeConfig) {
+        return new lambda.Version(this, name, {
+            lambda: this._lambda,
+            codeSha256,
+            description,
+            provisionedConcurrentExecutions: provisionedExecutions,
+            ...asyncInvokeConfig,
+        });
+    }
+    get memorySize() {
+        return this._memorySize;
+    }
+    get handler() {
+        return this._handler;
+    }
+    get environment() {
+        return this._environment;
+    }
+    get layers() {
+        return this._layers;
+    }
+    get maxEventAge() {
+        return undefined;
+    }
+    get retryAttempts() {
+        return undefined;
+    }
+    get reservedConcurrentExecutions() {
+        return this._reservedConcurrentExecutions;
+    }
+    get description() {
+        return undefined;
+    }
+    get initialPolicy() {
+        return undefined;
+    }
+    get logRetentionRole() {
+        return undefined;
+    }
+    get logRetentionRetryOptions() {
+        return undefined;
+    }
+    get tracing() {
+        return undefined;
+    }
+    get profiling() {
+        return undefined;
+    }
+    get profilingGroup() {
+        return undefined;
+    }
+    get environmentEncryption() {
+        return undefined;
+    }
+    get codeSigningConfig() {
+        return undefined;
+    }
+    get filesystemConfig() {
+        return undefined;
+    }
+    get filesystemConfigs() {
+        return undefined;
+    }
+    get ephemeralStorageSize() {
+        return undefined;
+    }
+    get runtimeManagementMode() {
+        return undefined;
+    }
+    get architectureLabel() {
+        return this._lambda.architecture.name;
+    }
+    get vpc() {
+        return this._vpc;
+    }
+    get vpcSubnets() {
+        return this._vpcSubnets;
+    }
+    get securityGroups() {
+        return this._securityGroups;
+    }
+    get allowAllOutbound() {
+        return undefined;
+    }
+    get allowPublicSubnet() {
+        return undefined;
+    }
+    get canCreateLambdaLogGroup() {
+        return true;
+    }
 }
 
 class JaypieQueuedLambda extends Construct {
@@ -985,7 +1147,7 @@ function exportEnvName(name, env = process.env) {
 class JaypieEnvSecret extends Construct {
     constructor(scope, id, props) {
         super(scope, id);
-        const { consumer = checkEnvIsConsumer(), envKey, export: exportParam, provider = checkEnvIsProvider(), roleTag, vendorTag, value, } = props || {};
+        const { consumer = checkEnvIsConsumer(), envKey, export: exportParam, generateSecretString, provider = checkEnvIsProvider(), roleTag, vendorTag, value, } = props || {};
         this._envKey = envKey;
         let exportName;
         if (!exportParam) {
@@ -1005,7 +1167,8 @@ class JaypieEnvSecret extends Construct {
         else {
             const secretValue = envKey && process.env[envKey] ? process.env[envKey] : value;
             const secretProps = {
-                secretStringValue: secretValue
+                generateSecretString,
+                secretStringValue: !generateSecretString && secretValue
                     ? SecretValue.unsafePlainText(secretValue)
                     : undefined,
             };