feat(cloudfront): add NodejsEdgeFunction construct

Adds NodejsEdgeFunction construct that combines EdgeFunction's cross-region
deployment capabilities with NodejsFunction's TypeScript bundling via esbuild.

This addresses the feature request in issue #12671 by providing a convenient
way to deploy TypeScript Lambda@Edge functions without manual bundling.

Key features:
- Extends EdgeFunction for automatic us-east-1 deployment
- Reuses NodejsFunction's prepareBundling utility for esbuild integration
- Validates runtime is Node.js family only
- Supports all NodejsFunction bundling options (minify, sourceMap, etc.)
- Includes integration test with AWS API assertions

Closes #12671

Author: abidhasan-aws

packages/@aws-cdk-testing/framework-integ/test/aws-cloudfront/test/integ.distribution-nodejs-edge-function.ts

@@ -0,0 +1,68 @@
+/// !cdk-integ *
+import * as path from 'path';
+import * as cdk from 'aws-cdk-lib';
+import * as cloudfront from 'aws-cdk-lib/aws-cloudfront';
+import * as integ from '@aws-cdk/integ-tests-alpha';
+import { ExpectedResult } from '@aws-cdk/integ-tests-alpha';
+import { TestOrigin } from './test-origin';
+import { STANDARD_NODEJS_RUNTIME } from '../../config';
+
+const app = new cdk.App();
+
+const region = 'eu-west-1';
+const stack = new cdk.Stack(app, 'integ-nodejs-edge-function', { 
+  env: { region: region },
+});
+
+// Test: NodejsEdgeFunction with cross-region deployment
+const edgeFunction = new cloudfront.experimental.NodejsEdgeFunction(stack, 'NodejsEdge', {
+  entry: path.join(__dirname, 'nodejs-edge-handler', 'index.ts'),
+  runtime: STANDARD_NODEJS_RUNTIME,
+});
+
+// Attach to CloudFront to verify integration
+const distribution = new cloudfront.Distribution(stack, 'Dist', {
+  defaultBehavior: {
+    origin: new TestOrigin('www.example.com'),
+    cachePolicy: cloudfront.CachePolicy.CACHING_DISABLED,
+    edgeLambdas: [{
+      functionVersion: edgeFunction.currentVersion,
+      eventType: cloudfront.LambdaEdgeEventType.VIEWER_REQUEST,
+    }],
+  },
+});
+
+const integTest = new integ.IntegTest(app, 'cdk-integ-nodejs-edge-function', {
+  testCases: [stack],
+  diffAssets: true,
+});
+
+// Assertion 1: Verify Lambda exists in us-east-1
+integTest.assertions.awsApiCall('Lambda', 'getFunction', {
+  FunctionName: edgeFunction.functionName,
+}).expect(ExpectedResult.objectLike({
+  Configuration: {
+    FunctionName: edgeFunction.functionName,
+  },
+})).provider.addToRolePolicy({
+  Effect: 'Allow',
+  Action: ['lambda:GetFunction'],
+  Resource: '*',
+});
+
+// Assertion 2: Verify CloudFront distribution has the edge lambda attached
+integTest.assertions.awsApiCall('CloudFront', 'getDistributionConfig', {
+  Id: distribution.distributionId,
+}).expect(ExpectedResult.objectLike({
+  DistributionConfig: {
+    DefaultCacheBehavior: {
+      LambdaFunctionAssociations: {
+        Quantity: 1,
+      },
+    },
+  },
+})).provider.addToRolePolicy({
+  Effect: 'Allow',
+  Action: ['cloudfront:GetDistributionConfig'],
+  Resource: '*',
+});

packages/@aws-cdk-testing/framework-integ/test/aws-cloudfront/test/nodejs-edge-handler/index.ts

@@ -0,0 +1,14 @@
+import { CloudFrontRequestEvent, CloudFrontRequestResult } from 'aws-lambda';
+
+export const handler = async (event: CloudFrontRequestEvent): Promise<CloudFrontRequestResult> => {
+  const request = event.Records[0].cf.request;
+  
+  // Simple TypeScript logic to verify bundling works
+  const customHeader: string = 'x-custom-header';
+  request.headers[customHeader] = [{
+    key: customHeader,
+    value: 'test-value',
+  }];
+  
+  return request;
+};

packages/aws-cdk-lib/aws-cloudfront/lib/experimental/index.ts

@@ -1 +1,2 @@
 export * from './edge-function';
+export * from './nodejs-edge-function';

packages/aws-cdk-lib/aws-cloudfront/lib/experimental/nodejs-edge-function.ts

@@ -0,0 +1,40 @@
+import { Construct } from 'constructs';
+import { EdgeFunction } from './edge-function';
+import * as lambda from '../../../aws-lambda';
+import { NodejsFunctionProps } from '../../../aws-lambda-nodejs';
+import { prepareBundling } from '../../../aws-lambda-nodejs/lib/bundling-preparation';
+import { ValidationError } from '../../../core';
+
+/**
+ * Properties for a NodejsEdgeFunction
+ */
+export interface NodejsEdgeFunctionProps extends NodejsFunctionProps {
+  /**
+   * The stack ID of Lambda@Edge function.
+   *
+   * @default - `edge-lambda-stack-${region}`
+   */
+  readonly stackId?: string;
+}
+
+/**
+ * A Node.js Lambda@Edge function bundled using esbuild
+ *
+ * @resource AWS::Lambda::Function
+ */
+export class NodejsEdgeFunction extends EdgeFunction {
+  constructor(scope: Construct, id: string, props: NodejsEdgeFunctionProps = {}) {
+    if (props.runtime && props.runtime.family !== lambda.RuntimeFamily.NODEJS) {
+      throw new ValidationError('Only `NODEJS` runtimes are supported.', scope);
+    }
+
+    const bundlingConfig = prepareBundling(scope, id, props, 'NodejsEdgeFunction');
+
+    super(scope, id, {
+      ...props,
+      runtime: bundlingConfig.runtime,
+      code: bundlingConfig.code,
+      handler: bundlingConfig.handler,
+    });
+  }
+}