@jaypie/constructs 1.1.21 → 1.1.22

package/dist/cjs/JaypieLambda.d.ts

@@ -0,0 +1,73 @@
+import { Construct } from "constructs";
+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 secretsmanager from "aws-cdk-lib/aws-secretsmanager";
+import { JaypieEnvSecret } from "./JaypieEnvSecret.js";
+export interface JaypieLambdaProps {
+    code: lambda.Code | string;
+    datadogApiKeyArn?: string;
+    environment?: {
+        [key: string]: string;
+    };
+    envSecrets?: {
+        [key: string]: secretsmanager.ISecret;
+    };
+    handler: string;
+    layers?: lambda.ILayerVersion[];
+    logRetention?: number;
+    memorySize?: number;
+    paramsAndSecrets?: lambda.ParamsAndSecretsLayerVersion | boolean;
+    paramsAndSecretsOptions?: {
+        cacheSize?: number;
+        logLevel?: lambda.ParamsAndSecretsLogLevel;
+        parameterStoreTtl?: number;
+        secretsManagerTtl?: number;
+    };
+    reservedConcurrentExecutions?: number;
+    roleTag?: string;
+    runtime?: lambda.Runtime;
+    secrets?: JaypieEnvSecret[];
+    timeout?: Duration | number;
+    vendorTag?: string;
+}
+export declare class JaypieLambda extends Construct implements lambda.IFunction {
+    private readonly _lambda;
+    private readonly _code;
+    constructor(scope: Construct, id: string, props: JaypieLambdaProps);
+    get lambda(): lambda.Function;
+    get code(): lambda.Code;
+    get functionArn(): string;
+    get functionName(): string;
+    get grantPrincipal(): iam.IPrincipal;
+    get role(): iam.IRole | undefined;
+    get architecture(): lambda.Architecture;
+    get connections(): import("aws-cdk-lib/aws-ec2").Connections;
+    get isBoundToVpc(): boolean;
+    get latestVersion(): lambda.IVersion;
+    get permissionsNode(): import("constructs").Node;
+    get resourceArnsForGrantInvoke(): string[];
+    addEventSource(source: lambda.IEventSource): void;
+    addEventSourceMapping(id: string, options: lambda.EventSourceMappingOptions): lambda.EventSourceMapping;
+    addFunctionUrl(options?: lambda.FunctionUrlOptions): lambda.FunctionUrl;
+    addPermission(id: string, permission: lambda.Permission): void;
+    addToRolePolicy(statement: iam.PolicyStatement): void;
+    configureAsyncInvoke(options: lambda.EventInvokeConfigOptions): void;
+    grantInvoke(grantee: iam.IGrantable): iam.Grant;
+    grantInvokeCompositePrincipal(compositePrincipal: iam.CompositePrincipal): iam.Grant[];
+    grantInvokeUrl(grantee: iam.IGrantable): iam.Grant;
+    metric(metricName: string, props?: cloudwatch.MetricOptions): cloudwatch.Metric;
+    metricDuration(props?: cloudwatch.MetricOptions): cloudwatch.Metric;
+    metricErrors(props?: cloudwatch.MetricOptions): cloudwatch.Metric;
+    metricInvocations(props?: cloudwatch.MetricOptions): cloudwatch.Metric;
+    metricThrottles(props?: cloudwatch.MetricOptions): cloudwatch.Metric;
+    grantInvokeLatestVersion(grantee: iam.IGrantable): iam.Grant;
+    grantInvokeVersion(grantee: iam.IGrantable, version: lambda.Version): iam.Grant;
+    get env(): {
+        account: string;
+        region: string;
+    };
+    get stack(): Stack;
+    applyRemovalPolicy(policy: RemovalPolicy): void;
+}

package/dist/cjs/JaypieQueuedLambda.d.ts

@@ -5,35 +5,15 @@ import * as sqs from "aws-cdk-lib/aws-sqs";
 import * as iam from "aws-cdk-lib/aws-iam";
 import * as cloudwatch from "aws-cdk-lib/aws-cloudwatch";
 import * as kms from "aws-cdk-lib/aws-kms";
-import * as secretsmanager from "aws-cdk-lib/aws-secretsmanager";
-import { JaypieEnvSecret } from "./JaypieEnvSecret.js";
-export interface JaypieQueuedLambdaProps {
+import { JaypieLambdaProps } from "./JaypieLambda.js";
+export interface JaypieQueuedLambdaProps extends JaypieLambdaProps {
     batchSize?: number;
-    code: lambda.Code | string;
-    environment?: {
-        [key: string]: string;
-    };
-    envSecrets?: {
-        [key: string]: secretsmanager.ISecret;
-    };
     fifo?: boolean;
-    handler: string;
-    layers?: lambda.ILayerVersion[];
-    logRetention?: number;
-    memorySize?: number;
-    paramsAndSecrets?: lambda.ParamsAndSecretsLayerVersion;
-    reservedConcurrentExecutions?: number;
-    roleTag?: string;
-    runtime?: lambda.Runtime;
-    secrets?: JaypieEnvSecret[];
-    timeout?: Duration | number;
-    vendorTag?: string;
     visibilityTimeout?: Duration | number;
 }
 export declare class JaypieQueuedLambda extends Construct implements lambda.IFunction, sqs.IQueue {
     private readonly _queue;
-    private readonly _lambda;
-    private readonly _code;
+    private readonly _lambdaConstruct;
     constructor(scope: Construct, id: string, props: JaypieQueuedLambdaProps);
     get queue(): sqs.Queue;
     get lambda(): lambda.Function;

package/dist/cjs/__tests__/JaypieLambda.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/cjs/index.cjs

@@ -215,47 +215,54 @@ class JaypieHostedZone extends constructs.Construct {
     }
 }
 
-class JaypieMongoDbSecret extends JaypieEnvSecret {
-    constructor(scope, id = "MongoConnectionString", props) {
-        const defaultProps = {
-            envKey: "MONGODB_URI",
-            roleTag: cdk$1.CDK.ROLE.STORAGE,
-            vendorTag: cdk$1.CDK.VENDOR.MONGODB,
-            ...props,
-        };
-        super(scope, id, defaultProps);
-    }
-}
-
-class JaypieOpenAiSecret extends JaypieEnvSecret {
-    constructor(scope, id = "OpenAiApiKey", props) {
-        const defaultProps = {
-            envKey: "OPENAI_API_KEY",
-            roleTag: cdk$1.CDK.ROLE.PROCESSING,
-            vendorTag: cdk$1.CDK.VENDOR.OPENAI,
-            ...props,
-        };
-        super(scope, id, defaultProps);
-    }
-}
-
-class JaypieQueuedLambda extends constructs.Construct {
+class JaypieLambda extends constructs.Construct {
     constructor(scope, id, props) {
         super(scope, id);
-        const { batchSize = 1, code, environment = {}, envSecrets = {}, fifo = true, handler = "index.handler", layers = [], logRetention = cdk$1.CDK.LAMBDA.LOG_RETENTION, memorySize = cdk$1.CDK.LAMBDA.MEMORY_SIZE, paramsAndSecrets, reservedConcurrentExecutions, roleTag, runtime = lambda__namespace.Runtime.NODEJS_20_X, secrets = [], timeout = cdk.Duration.seconds(cdk$1.CDK.DURATION.LAMBDA_WORKER), vendorTag, visibilityTimeout = cdk.Duration.seconds(cdk$1.CDK.DURATION.LAMBDA_WORKER), } = props;
+        const { code, datadogApiKeyArn, environment: initialEnvironment = {}, envSecrets = {}, handler = "index.handler", layers = [], logRetention = cdk$1.CDK.LAMBDA.LOG_RETENTION, memorySize = cdk$1.CDK.LAMBDA.MEMORY_SIZE, paramsAndSecrets, paramsAndSecretsOptions, reservedConcurrentExecutions, roleTag, runtime = lambda__namespace.Runtime.NODEJS_20_X, secrets = [], timeout = cdk.Duration.seconds(cdk$1.CDK.DURATION.LAMBDA_WORKER), vendorTag, } = props;
+        // Create a mutable copy of the environment variables
+        let environment = { ...initialEnvironment };
         this._code = typeof code === "string" ? lambda__namespace.Code.fromAsset(code) : code;
-        // Create SQS Queue
-        this._queue = new sqs__namespace.Queue(this, "Queue", {
-            fifo,
-            visibilityTimeout: typeof visibilityTimeout === "number"
-                ? cdk.Duration.seconds(visibilityTimeout)
-                : visibilityTimeout,
-        });
-        if (roleTag) {
-            cdk.Tags.of(this._queue).add(cdk$1.CDK.TAG.ROLE, roleTag);
+        // 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__namespace.LayerVersion.fromLayerVersionArn(this, "DatadogNodeLayer", `arn:aws:lambda:${cdk.Stack.of(this).region}:464622532012:layer:Datadog-Node20-x:${cdk$1.CDK.DATADOG.LAYER.NODE}`);
+            resolvedLayers.push(datadogNodeLayer);
+            // Add Datadog Extension layer
+            const datadogExtensionLayer = lambda__namespace.LayerVersion.fromLayerVersionArn(this, "DatadogExtensionLayer", `arn:aws:lambda:${cdk.Stack.of(this).region}:464622532012:layer:Datadog-Extension:${cdk$1.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$1.CDK.DATADOG.SITE,
+                DD_TAGS: `${cdk$1.CDK.TAG.SPONSOR}:${process.env.PROJECT_SPONSOR || ""}`,
+            });
         }
-        if (vendorTag) {
-            cdk.Tags.of(this._queue).add(cdk$1.CDK.TAG.VENDOR, vendorTag);
+        // Configure ParamsAndSecrets layer
+        let resolvedParamsAndSecrets = undefined;
+        if (paramsAndSecrets !== false) {
+            if (paramsAndSecrets instanceof lambda__namespace.ParamsAndSecretsLayerVersion) {
+                resolvedParamsAndSecrets = paramsAndSecrets;
+            }
+            else {
+                // Create default ParamsAndSecrets layer
+                resolvedParamsAndSecrets =
+                    lambda__namespace.ParamsAndSecretsLayerVersion.fromVersion(lambda__namespace.ParamsAndSecretsVersions.V1_0_103, {
+                        cacheSize: paramsAndSecretsOptions?.cacheSize,
+                        logLevel: paramsAndSecretsOptions?.logLevel ||
+                            lambda__namespace.ParamsAndSecretsLogLevel.WARN,
+                        parameterStoreTtl: paramsAndSecretsOptions?.parameterStoreTtl,
+                        secretsManagerTtl: paramsAndSecretsOptions?.secretsManagerTtl,
+                    });
+            }
         }
         // Process secrets environment variables
         const secretsEnvironment = Object.entries(envSecrets).reduce((acc, [key, secret]) => ({
@@ -276,16 +283,15 @@ class JaypieQueuedLambda extends constructs.Construct {
         this._lambda = new lambda__namespace.Function(this, "Function", {
             code: this._code,
             environment: {
-                CDK_ENV_QUEUE_URL: this._queue.queueUrl,
                 ...environment,
                 ...secretsEnvironment,
                 ...jaypieSecretsEnvironment,
             },
             handler,
-            layers,
+            layers: resolvedLayers,
             logRetention,
             memorySize,
-            paramsAndSecrets,
+            paramsAndSecrets: resolvedParamsAndSecrets,
             reservedConcurrentExecutions,
             runtime,
             timeout: typeof timeout === "number" ? cdk.Duration.seconds(timeout) : timeout,
@@ -299,11 +305,11 @@ class JaypieQueuedLambda extends constructs.Construct {
             secret.grantRead(this);
             secret.grantRead(this._lambda);
         });
-        this._queue.grantConsumeMessages(this._lambda);
-        this._queue.grantSendMessages(this._lambda);
-        this._lambda.addEventSource(new lambdaEventSources__namespace.SqsEventSource(this._queue, {
-            batchSize,
-        }));
+        // Grant Datadog API key read permission if applicable
+        if (resolvedDatadogApiKeyArn) {
+            const datadogApiKey = secretsmanager__namespace.Secret.fromSecretCompleteArn(this, "DatadogApiKeyGrant", resolvedDatadogApiKeyArn);
+            datadogApiKey.grantRead(this._lambda);
+        }
         if (roleTag) {
             cdk.Tags.of(this._lambda).add(cdk$1.CDK.TAG.ROLE, roleTag);
         }
@@ -312,9 +318,6 @@ class JaypieQueuedLambda extends constructs.Construct {
         }
     }
     // Public accessors
-    get queue() {
-        return this._queue;
-    }
     get lambda() {
         return this._lambda;
     }
@@ -412,6 +415,178 @@ class JaypieQueuedLambda extends constructs.Construct {
     }
     applyRemovalPolicy(policy) {
         this._lambda.applyRemovalPolicy(policy);
+    }
+}
+
+class JaypieMongoDbSecret extends JaypieEnvSecret {
+    constructor(scope, id = "MongoConnectionString", props) {
+        const defaultProps = {
+            envKey: "MONGODB_URI",
+            roleTag: cdk$1.CDK.ROLE.STORAGE,
+            vendorTag: cdk$1.CDK.VENDOR.MONGODB,
+            ...props,
+        };
+        super(scope, id, defaultProps);
+    }
+}
+
+class JaypieOpenAiSecret extends JaypieEnvSecret {
+    constructor(scope, id = "OpenAiApiKey", props) {
+        const defaultProps = {
+            envKey: "OPENAI_API_KEY",
+            roleTag: cdk$1.CDK.ROLE.PROCESSING,
+            vendorTag: cdk$1.CDK.VENDOR.OPENAI,
+            ...props,
+        };
+        super(scope, id, defaultProps);
+    }
+}
+
+class JaypieQueuedLambda extends constructs.Construct {
+    constructor(scope, id, props) {
+        super(scope, id);
+        const { batchSize = 1, code, environment = {}, envSecrets = {}, fifo = true, handler = "index.handler", layers = [], logRetention = cdk$1.CDK.LAMBDA.LOG_RETENTION, memorySize = cdk$1.CDK.LAMBDA.MEMORY_SIZE, paramsAndSecrets, reservedConcurrentExecutions, roleTag, runtime = lambda__namespace.Runtime.NODEJS_20_X, secrets = [], timeout = cdk.Duration.seconds(cdk$1.CDK.DURATION.LAMBDA_WORKER), vendorTag, visibilityTimeout = cdk.Duration.seconds(cdk$1.CDK.DURATION.LAMBDA_WORKER), } = props;
+        // Create SQS Queue
+        this._queue = new sqs__namespace.Queue(this, "Queue", {
+            fifo,
+            visibilityTimeout: typeof visibilityTimeout === "number"
+                ? cdk.Duration.seconds(visibilityTimeout)
+                : visibilityTimeout,
+        });
+        if (roleTag) {
+            cdk.Tags.of(this._queue).add(cdk$1.CDK.TAG.ROLE, roleTag);
+        }
+        if (vendorTag) {
+            cdk.Tags.of(this._queue).add(cdk$1.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__namespace.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: cdk.Stack.of(this).account,
+            region: cdk.Stack.of(this).region,
+        };
+    }
+    get stack() {
+        return cdk.Stack.of(this);
+    }
+    applyRemovalPolicy(policy) {
+        this._lambdaConstruct.applyRemovalPolicy(policy);
         this._queue.applyRemovalPolicy(policy);
     }
     // IQueue implementation
@@ -763,6 +938,7 @@ class JaypieTraceSigningKeySecret extends JaypieEnvSecret {
 
 exports.JaypieEnvSecret = JaypieEnvSecret;
 exports.JaypieHostedZone = JaypieHostedZone;
+exports.JaypieLambda = JaypieLambda;
 exports.JaypieMongoDbSecret = JaypieMongoDbSecret;
 exports.JaypieOpenAiSecret = JaypieOpenAiSecret;
 exports.JaypieQueuedLambda = JaypieQueuedLambda;