@ashishpandeyone/cdk-lambda-web-function 0.1.4 → 0.1.6

package/lib/web-function-origin.js

@@ -0,0 +1,201 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebFunctionOrigin = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const aws_cdk_lib_1 = require("aws-cdk-lib");
+const cloudfront = __importStar(require("aws-cdk-lib/aws-cloudfront"));
+const iam = __importStar(require("aws-cdk-lib/aws-iam"));
+const enums_1 = require("./enums");
+/**
+ * Regions that are not enabled by default. CloudFront can't sign a request that a MULTI_REGION endpoint routes
+ * to one of them, so the origin returns 403 (CloudFront Developer Guide, Lambda Web Function origins, 2026-10).
+ */
+const OPT_IN_REGIONS = [
+    'af-south-1', 'ap-east-1', 'ap-east-2', 'ap-south-2', 'ap-southeast-3', 'ap-southeast-4', 'ap-southeast-5', 'ap-southeast-6',
+    'ap-southeast-7', 'ca-west-1', 'eu-central-2', 'eu-south-1', 'eu-south-2', 'il-central-1', 'me-central-1', 'me-south-1', 'mx-central-1',
+];
+/**
+ * A CloudFront origin for a Web Function endpoint.
+ *
+ * Use `WebFunctionOrigin.withOriginAccessControl(endpoint)` for an `AWS_IAM` endpoint: CloudFront signs every request,
+ * and only your distribution may call the endpoint. `new WebFunctionOrigin(endpoint)` is for a public (`NONE`) endpoint.
+ */
+class WebFunctionOrigin extends cloudfront.OriginBase {
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "@ashishpandeyone/cdk-lambda-web-function.WebFunctionOrigin", version: "0.1.6" };
+    /**
+     * An origin for an `AWS_IAM` endpoint, with origin access control: CloudFront signs every request to the endpoint
+     * (`always-amz-auth`, which keeps the viewer's `Authorization` header for your application), and the function's
+     * resource policy allows `cloudfront.amazonaws.com` to call this endpoint on behalf of this distribution only.
+     *
+     * The distribution must be in the function's stack.
+     */
+    static withOriginAccessControl(endpoint, props = {}) {
+        if (endpoint.authType !== enums_1.WebFunctionAuthType.AWS_IAM) {
+            throw new Error(`${endpoint.node.path}: origin access control needs an AWS_IAM endpoint (this one is ${endpoint.authType}, which Lambda doesn't authenticate); use new WebFunctionOrigin(endpoint)`);
+        }
+        if (endpoint.endpointType === enums_1.WebFunctionEndpointType.MULTI_REGION) {
+            const optIn = endpoint.regions.filter((r) => OPT_IN_REGIONS.includes(r));
+            if (optIn.length > 0) {
+                throw new Error(`${endpoint.node.path}: CloudFront can't sign requests that a MULTI_REGION endpoint routes to opt-in regions (${optIn.join(', ')}); use a PER_REGION endpoint and one origin per region`);
+            }
+        }
+        return new WebFunctionOriginWithOac(endpoint, props);
+    }
+    props;
+    constructor(endpoint, props = {}) {
+        if (endpoint.authType === enums_1.WebFunctionAuthType.AWS_IAM) {
+            throw new Error(`${endpoint.node.path}: CloudFront can only call an AWS_IAM endpoint with origin access control; use WebFunctionOrigin.withOriginAccessControl(endpoint)`);
+        }
+        super(originDomainName(endpoint, props.region), props);
+        validateTimeouts(endpoint, props);
+        this.validateResponseCompletionTimeoutWithReadTimeout(props.responseCompletionTimeout, props.readTimeout);
+        this.props = props;
+    }
+    renderCustomOriginConfig() {
+        return customOriginConfig(this.props);
+    }
+}
+exports.WebFunctionOrigin = WebFunctionOrigin;
+class WebFunctionOriginWithOac extends cloudfront.OriginBase {
+    endpoint;
+    props;
+    signingProtocol;
+    constructor(endpoint, props) {
+        super(originDomainName(endpoint, props.region), props);
+        this.endpoint = endpoint;
+        this.props = props;
+        validateTimeouts(endpoint, props);
+        this.validateResponseCompletionTimeoutWithReadTimeout(props.responseCompletionTimeout, props.readTimeout);
+        // The global domain routes to any of the endpoint's regions, so CloudFront signs for all of them.
+        this.signingProtocol = endpoint.endpointType === enums_1.WebFunctionEndpointType.MULTI_REGION ? 'sigv4a' : 'sigv4';
+        if (props.originAccessControl)
+            assertOriginAccessControl(endpoint, props.originAccessControl, this.signingProtocol);
+    }
+    bind(scope, options) {
+        const config = super.bind(scope, options);
+        const stack = aws_cdk_lib_1.Stack.of(scope);
+        if (stack !== aws_cdk_lib_1.Stack.of(this.endpoint)) {
+            // The resource policy names the distribution, and the distribution names the endpoint: a reference cycle.
+            throw new Error(`${scope.node.path}: a distribution with a WebFunctionOrigin must be in the function's stack (${aws_cdk_lib_1.Stack.of(this.endpoint).stackName})`);
+        }
+        if (options.distributionId === undefined) {
+            throw new Error(`${scope.node.path}: a WebFunctionOrigin with origin access control must be used by a cloudfront.Distribution (its ID scopes the resource policy)`);
+        }
+        const oac = this.props.originAccessControl ?? this.sharedOriginAccessControl(stack);
+        const result = this.endpoint.webFunction.addToResourcePolicy(new iam.PolicyStatement({
+            principals: [new iam.ServicePrincipal('cloudfront.amazonaws.com')],
+            actions: ['lambda:InvokeWebFunctionEndpoint'],
+            resources: [this.endpoint.endpointArn],
+            conditions: {
+                StringEquals: {
+                    'aws:SourceArn': stack.formatArn({ service: 'cloudfront', region: '', resource: 'distribution', resourceName: options.distributionId }),
+                },
+            },
+        }));
+        if (!result.statementAdded) {
+            throw new Error(`${scope.node.path}: could not add CloudFront to the resource policy of ${this.endpoint.webFunction.node.path}`);
+        }
+        return { ...config, originProperty: { ...config.originProperty, originAccessControlId: oac.originAccessControlRef.originAccessControlId } };
+    }
+    renderCustomOriginConfig() {
+        return customOriginConfig(this.props);
+    }
+    /** One origin access control per stack and signing protocol, shared by the stack's Web Function origins. */
+    sharedOriginAccessControl(scope) {
+        const id = `WebFunctionOriginAccessControl${this.signingProtocol === 'sigv4a' ? 'SigV4a' : 'SigV4'}`;
+        const existing = scope.node.tryFindChild(id);
+        if (existing)
+            return existing;
+        const oac = new cloudfront.CfnOriginAccessControl(scope, id, {
+            originAccessControlConfig: {
+                // Unique in the account, like the names CDK generates for its own origin access controls.
+                name: aws_cdk_lib_1.Lazy.string({ produce: () => aws_cdk_lib_1.Names.uniqueResourceName(oac, { maxLength: 64 }) }),
+                description: `Lambda Web Function origins (${this.signingProtocol})`,
+                // The CDK enums have neither value yet. Lambda Web Function origins accept only always-amz-auth.
+                originAccessControlOriginType: 'lambda',
+                signingBehavior: 'always-amz-auth',
+                signingProtocol: this.signingProtocol,
+            },
+        });
+        return oac;
+    }
+}
+/**
+ * Checks a given origin access control when its configuration is known (one created in this app, not imported):
+ * CloudFront rejects other settings for a Web Function origin only when the distribution deploys.
+ */
+function assertOriginAccessControl(endpoint, oac, protocol) {
+    const cfn = oac instanceof cloudfront.CfnOriginAccessControl
+        ? oac
+        : oac.node.children.find((c) => c instanceof cloudfront.CfnOriginAccessControl);
+    if (cfn === undefined)
+        return;
+    const config = aws_cdk_lib_1.Stack.of(cfn).resolve(cfn.originAccessControlConfig);
+    const expected = { OriginAccessControlOriginType: 'lambda', SigningBehavior: 'always-amz-auth', SigningProtocol: protocol };
+    const wrong = Object.entries(expected).filter(([key, value]) => {
+        const actual = config[key] ?? config[key.charAt(0).toLowerCase() + key.slice(1)];
+        return typeof actual === 'string' && actual !== value;
+    });
+    if (wrong.length > 0) {
+        throw new Error(`${endpoint.node.path}: the origin access control ${oac.node.path} must have ${wrong.map(([k, v]) => `${k} '${v}'`).join(', ')} for this endpoint`);
+    }
+}
+function originDomainName(endpoint, region) {
+    if (region === undefined)
+        return endpoint.domainName;
+    if (endpoint.endpointType !== enums_1.WebFunctionEndpointType.PER_REGION) {
+        throw new Error(`${endpoint.node.path}: region is only for PER_REGION endpoints (this one is ${endpoint.endpointType})`);
+    }
+    return endpoint.regionalDomainName(region);
+}
+function validateTimeouts(endpoint, props) {
+    for (const [name, value] of [['readTimeout', props.readTimeout], ['keepaliveTimeout', props.keepaliveTimeout]]) {
+        const seconds = value?.toSeconds();
+        if (seconds !== undefined && !aws_cdk_lib_1.Token.isUnresolved(seconds) && (!Number.isInteger(seconds) || seconds < 1)) {
+            throw new Error(`${endpoint.node.path}: ${name} must be a whole number of seconds, at least 1, got ${seconds}`);
+        }
+    }
+}
+function customOriginConfig(props) {
+    return {
+        originProtocolPolicy: cloudfront.OriginProtocolPolicy.HTTPS_ONLY,
+        originSslProtocols: [cloudfront.OriginSslPolicy.TLS_V1_2],
+        originReadTimeout: props.readTimeout?.toSeconds(),
+        originKeepaliveTimeout: props.keepaliveTimeout?.toSeconds(),
+        ipAddressType: props.ipAddressType,
+    };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"web-function-origin.js","sourceRoot":"","sources":["../src/web-function-origin.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,6CAAkE;AAClE,uEAAyD;AACzD,yDAA2C;AAE3C,mCAAuE;AAGvE;;;GAGG;AACH,MAAM,cAAc,GAAG;IACrB,YAAY,EAAE,WAAW,EAAE,WAAW,EAAE,YAAY,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,gBAAgB;IAC5H,gBAAgB,EAAE,WAAW,EAAE,cAAc,EAAE,YAAY,EAAE,YAAY,EAAE,cAAc,EAAE,cAAc,EAAE,YAAY,EAAE,cAAc;CACxI,CAAC;AAmDF;;;;;GAKG;AACH,MAAa,iBAAkB,SAAQ,UAAU,CAAC,UAAU;;IAC1D;;;;;;OAMG;IACI,MAAM,CAAC,uBAAuB,CAAC,QAA6B,EAAE,QAAuC,EAAE;QAC5G,IAAI,QAAQ,CAAC,QAAQ,KAAK,2BAAmB,CAAC,OAAO,EAAE,CAAC;YACtD,MAAM,IAAI,KAAK,CAAC,GAAG,QAAQ,CAAC,IAAI,CAAC,IAAI,kEAAkE,QAAQ,CAAC,QAAQ,2EAA2E,CAAC,CAAC;QACvM,CAAC;QACD,IAAI,QAAQ,CAAC,YAAY,KAAK,+BAAuB,CAAC,YAAY,EAAE,CAAC;YACnE,MAAM,KAAK,GAAG,QAAQ,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,cAAc,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC;YACzE,IAAI,KAAK,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;gBACrB,MAAM,IAAI,KAAK,CAAC,GAAG,QAAQ,CAAC,IAAI,CAAC,IAAI,2FAA2F,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,wDAAwD,CAAC,CAAC;YAC5M,CAAC;QACH,CAAC;QACD,OAAO,IAAI,wBAAwB,CAAC,QAAQ,EAAE,KAAK,CAAC,CAAC;IACvD,CAAC;IAEgB,KAAK,CAAyB;IAE/C,YAAY,QAA6B,EAAE,QAAgC,EAAE;QAC3E,IAAI,QAAQ,CAAC,QAAQ,KAAK,2BAAmB,CAAC,OAAO,EAAE,CAAC;YACtD,MAAM,IAAI,KAAK,CAAC,GAAG,QAAQ,CAAC,IAAI,CAAC,IAAI,oIAAoI,CAAC,CAAC;QAC7K,CAAC;QACD,KAAK,CAAC,gBAAgB,CAAC,QAAQ,EAAE,KAAK,CAAC,MAAM,CAAC,EAAE,KAAK,CAAC,CAAC;QACvD,gBAAgB,CAAC,QAAQ,EAAE,KAAK,CAAC,CAAC;QAClC,IAAI,CAAC,gDAAgD,CAAC,KAAK,CAAC,yBAAyB,EAAE,KAAK,CAAC,WAAW,CAAC,CAAC;QAC1G,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC;IACrB,CAAC;IAES,wBAAwB;QAChC,OAAO,kBAAkB,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;IACxC,CAAC;;AAnCH,8CAoCC;AAED,MAAM,wBAAyB,SAAQ,UAAU,CAAC,UAAU;IAG7B;IAAgD;IAF5D,eAAe,CAAqB;IAErD,YAA6B,QAA6B,EAAmB,KAAoC;QAC/G,KAAK,CAAC,gBAAgB,CAAC,QAAQ,EAAE,KAAK,CAAC,MAAM,CAAC,EAAE,KAAK,CAAC,CAAC;QAD5B,aAAQ,GAAR,QAAQ,CAAqB;QAAmB,UAAK,GAAL,KAAK,CAA+B;QAE/G,gBAAgB,CAAC,QAAQ,EAAE,KAAK,CAAC,CAAC;QAClC,IAAI,CAAC,gDAAgD,CAAC,KAAK,CAAC,yBAAyB,EAAE,KAAK,CAAC,WAAW,CAAC,CAAC;QAC1G,kGAAkG;QAClG,IAAI,CAAC,eAAe,GAAG,QAAQ,CAAC,YAAY,KAAK,+BAAuB,CAAC,YAAY,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,OAAO,CAAC;QAC3G,IAAI,KAAK,CAAC,mBAAmB;YAAE,yBAAyB,CAAC,QAAQ,EAAE,KAAK,CAAC,mBAAmB,EAAE,IAAI,CAAC,eAAe,CAAC,CAAC;IACtH,CAAC;IAEM,IAAI,CAAC,KAAgB,EAAE,OAAqC;QACjE,MAAM,MAAM,GAAG,KAAK,CAAC,IAAI,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC;QAC1C,MAAM,KAAK,GAAG,mBAAK,CAAC,EAAE,CAAC,KAAK,CAAC,CAAC;QAC9B,IAAI,KAAK,KAAK,mBAAK,CAAC,EAAE,CAAC,IAAI,CAAC,QAAQ,CAAC,EAAE,CAAC;YACtC,0GAA0G;YAC1G,MAAM,IAAI,KAAK,CAAC,GAAG,KAAK,CAAC,IAAI,CAAC,IAAI,8EAA8E,mBAAK,CAAC,EAAE,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,SAAS,GAAG,CAAC,CAAC;QACxJ,CAAC;QACD,IAAI,OAAO,CAAC,cAAc,KAAK,SAAS,EAAE,CAAC;YACzC,MAAM,IAAI,KAAK,CAAC,GAAG,KAAK,CAAC,IAAI,CAAC,IAAI,gIAAgI,CAAC,CAAC;QACtK,CAAC;QACD,MAAM,GAAG,GAAG,IAAI,CAAC,KAAK,CAAC,mBAAmB,IAAI,IAAI,CAAC,yBAAyB,CAAC,KAAK,CAAC,CAAC;QAEpF,MAAM,MAAM,GAAG,IAAI,CAAC,QAAQ,CAAC,WAAW,CAAC,mBAAmB,CAAC,IAAI,GAAG,CAAC,eAAe,CAAC;YACnF,UAAU,EAAE,CAAC,IAAI,GAAG,CAAC,gBAAgB,CAAC,0BAA0B,CAAC,CAAC;YAClE,OAAO,EAAE,CAAC,kCAAkC,CAAC;YAC7C,SAAS,EAAE,CAAC,IAAI,CAAC,QAAQ,CAAC,WAAW,CAAC;YACtC,UAAU,EAAE;gBACV,YAAY,EAAE;oBACZ,eAAe,EAAE,KAAK,CAAC,SAAS,CAAC,EAAE,OAAO,EAAE,YAAY,EAAE,MAAM,EAAE,EAAE,EAAE,QAAQ,EAAE,cAAc,EAAE,YAAY,EAAE,OAAO,CAAC,cAAc,EAAE,CAAC;iBACxI;aACF;SACF,CAAC,CAAC,CAAC;QACJ,IAAI,CAAC,MAAM,CAAC,cAAc,EAAE,CAAC;YAC3B,MAAM,IAAI,KAAK,CAAC,GAAG,KAAK,CAAC,IAAI,CAAC,IAAI,wDAAwD,IAAI,CAAC,QAAQ,CAAC,WAAW,CAAC,IAAI,CAAC,IAAI,EAAE,CAAC,CAAC;QACnI,CAAC;QAED,OAAO,EAAE,GAAG,MAAM,EAAE,cAAc,EAAE,EAAE,GAAG,MAAM,CAAC,cAAe,EAAE,qBAAqB,EAAE,GAAG,CAAC,sBAAsB,CAAC,qBAAqB,EAAE,EAAE,CAAC;IAC/I,CAAC;IAES,wBAAwB;QAChC,OAAO,kBAAkB,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;IACxC,CAAC;IAED,4GAA4G;IACpG,yBAAyB,CAAC,KAAY;QAC5C,MAAM,EAAE,GAAG,iCAAiC,IAAI,CAAC,eAAe,KAAK,QAAQ,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,OAAO,EAAE,CAAC;QACrG,MAAM,QAAQ,GAAG,KAAK,CAAC,IAAI,CAAC,YAAY,CAAC,EAAE,CAAkD,CAAC;QAC9F,IAAI,QAAQ;YAAE,OAAO,QAAQ,CAAC;QAC9B,MAAM,GAAG,GAAsC,IAAI,UAAU,CAAC,sBAAsB,CAAC,KAAK,EAAE,EAAE,EAAE;YAC9F,yBAAyB,EAAE;gBACzB,0FAA0F;gBAC1F,IAAI,EAAE,kBAAI,CAAC,MAAM,CAAC,EAAE,OAAO,EAAE,GAAG,EAAE,CAAC,mBAAK,CAAC,kBAAkB,CAAC,GAAG,EAAE,EAAE,SAAS,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC;gBACtF,WAAW,EAAE,gCAAgC,IAAI,CAAC,eAAe,GAAG;gBACpE,iGAAiG;gBACjG,6BAA6B,EAAE,QAAQ;gBACvC,eAAe,EAAE,iBAAiB;gBAClC,eAAe,EAAE,IAAI,CAAC,eAAe;aACtC;SACF,CAAC,CAAC;QACH,OAAO,GAAG,CAAC;IACb,CAAC;CACF;AAED;;;GAGG;AACH,SAAS,yBAAyB,CAAC,QAA6B,EAAE,GAAuC,EAAE,QAAgB;IACzH,MAAM,GAAG,GAAG,GAAG,YAAY,UAAU,CAAC,sBAAsB;QAC1D,CAAC,CAAC,GAAG;QACL,CAAC,CAAC,GAAG,CAAC,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAC,EAA0C,EAAE,CAAC,CAAC,YAAY,UAAU,CAAC,sBAAsB,CAAC,CAAC;IAC1H,IAAI,GAAG,KAAK,SAAS;QAAE,OAAO;IAC9B,MAAM,MAAM,GAAG,mBAAK,CAAC,EAAE,CAAC,GAAG,CAAC,CAAC,OAAO,CAAC,GAAG,CAAC,yBAAyB,CAA4B,CAAC;IAC/F,MAAM,QAAQ,GAA2B,EAAE,6BAA6B,EAAE,QAAQ,EAAE,eAAe,EAAE,iBAAiB,EAAE,eAAe,EAAE,QAAQ,EAAE,CAAC;IACpJ,MAAM,KAAK,GAAG,MAAM,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,GAAG,EAAE,KAAK,CAAC,EAAE,EAAE;QAC7D,MAAM,MAAM,GAAG,MAAM,CAAC,GAAG,CAAC,IAAI,MAAM,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,WAAW,EAAE,GAAG,GAAG,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;QACjF,OAAO,OAAO,MAAM,KAAK,QAAQ,IAAI,MAAM,KAAK,KAAK,CAAC;IACxD,CAAC,CAAC,CAAC;IACH,IAAI,KAAK,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;QACrB,MAAM,IAAI,KAAK,CAAC,GAAG,QAAQ,CAAC,IAAI,CAAC,IAAI,+BAA+B,GAAG,CAAC,IAAI,CAAC,IAAI,cAAc,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC,GAAG,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,oBAAoB,CAAC,CAAC;IACtK,CAAC;AACH,CAAC;AAED,SAAS,gBAAgB,CAAC,QAA6B,EAAE,MAAe;IACtE,IAAI,MAAM,KAAK,SAAS;QAAE,OAAO,QAAQ,CAAC,UAAU,CAAC;IACrD,IAAI,QAAQ,CAAC,YAAY,KAAK,+BAAuB,CAAC,UAAU,EAAE,CAAC;QACjE,MAAM,IAAI,KAAK,CAAC,GAAG,QAAQ,CAAC,IAAI,CAAC,IAAI,0DAA0D,QAAQ,CAAC,YAAY,GAAG,CAAC,CAAC;IAC3H,CAAC;IACD,OAAO,QAAQ,CAAC,kBAAkB,CAAC,MAAM,CAAC,CAAC;AAC7C,CAAC;AAED,SAAS,gBAAgB,CAAC,QAA6B,EAAE,KAA6B;IACpF,KAAK,MAAM,CAAC,IAAI,EAAE,KAAK,CAAC,IAAI,CAAC,CAAC,aAAa,EAAE,KAAK,CAAC,WAAW,CAAC,EAAE,CAAC,kBAAkB,EAAE,KAAK,CAAC,gBAAgB,CAAC,CAAU,EAAE,CAAC;QACxH,MAAM,OAAO,GAAG,KAAK,EAAE,SAAS,EAAE,CAAC;QACnC,IAAI,OAAO,KAAK,SAAS,IAAI,CAAC,mBAAK,CAAC,YAAY,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,MAAM,CAAC,SAAS,CAAC,OAAO,CAAC,IAAI,OAAO,GAAG,CAAC,CAAC,EAAE,CAAC;YACzG,MAAM,IAAI,KAAK,CAAC,GAAG,QAAQ,CAAC,IAAI,CAAC,IAAI,KAAK,IAAI,uDAAuD,OAAO,EAAE,CAAC,CAAC;QAClH,CAAC;IACH,CAAC;AACH,CAAC;AAED,SAAS,kBAAkB,CAAC,KAA6B;IACvD,OAAO;QACL,oBAAoB,EAAE,UAAU,CAAC,oBAAoB,CAAC,UAAU;QAChE,kBAAkB,EAAE,CAAC,UAAU,CAAC,eAAe,CAAC,QAAQ,CAAC;QACzD,iBAAiB,EAAE,KAAK,CAAC,WAAW,EAAE,SAAS,EAAE;QACjD,sBAAsB,EAAE,KAAK,CAAC,gBAAgB,EAAE,SAAS,EAAE;QAC3D,aAAa,EAAE,KAAK,CAAC,aAAa;KACnC,CAAC;AACJ,CAAC","sourcesContent":["import { Duration, Lazy, Names, Stack, Token } from 'aws-cdk-lib';\nimport * as cloudfront from 'aws-cdk-lib/aws-cloudfront';\nimport * as iam from 'aws-cdk-lib/aws-iam';\nimport type { Construct } from 'constructs';\nimport { WebFunctionAuthType, WebFunctionEndpointType } from './enums';\nimport type { WebFunctionEndpoint } from './web-function-endpoint';\n\n/**\n * Regions that are not enabled by default. CloudFront can't sign a request that a MULTI_REGION endpoint routes\n * to one of them, so the origin returns 403 (CloudFront Developer Guide, Lambda Web Function origins, 2026-10).\n */\nconst OPT_IN_REGIONS = [\n  'af-south-1', 'ap-east-1', 'ap-east-2', 'ap-south-2', 'ap-southeast-3', 'ap-southeast-4', 'ap-southeast-5', 'ap-southeast-6',\n  'ap-southeast-7', 'ca-west-1', 'eu-central-2', 'eu-south-1', 'eu-south-2', 'il-central-1', 'me-central-1', 'me-south-1', 'mx-central-1',\n];\n\n/**\n * Properties for a Web Function endpoint origin.\n */\nexport interface WebFunctionOriginProps extends cloudfront.OriginProps {\n  /**\n   * For a `PER_REGION` endpoint: the region whose URL CloudFront calls. Only one region per origin; use an origin\n   * group or one origin per behavior for more.\n   *\n   * @default - the endpoint's home region\n   */\n  readonly region?: string;\n\n  /**\n   * How long CloudFront waits for a response from the origin. Above 120 seconds needs a CloudFront quota increase.\n   *\n   * @default Duration.seconds(30)\n   */\n  readonly readTimeout?: Duration;\n\n  /**\n   * How long CloudFront keeps its connection to the origin open.\n   *\n   * @default Duration.seconds(5)\n   */\n  readonly keepaliveTimeout?: Duration;\n\n  /**\n   * Which IP protocol CloudFront uses to connect to the origin.\n   *\n   * @default OriginIpAddressType.IPV4\n   */\n  readonly ipAddressType?: cloudfront.OriginIpAddressType;\n}\n\n/**\n * Properties for a Web Function endpoint origin with origin access control.\n */\nexport interface WebFunctionOriginWithOacProps extends WebFunctionOriginProps {\n  /**\n   * The origin access control. It must have origin type `lambda`, signing behavior `always-amz-auth`, and signing\n   * protocol `sigv4` (a regional endpoint) or `sigv4a` (a `MULTI_REGION` endpoint's global domain). Checked at\n   * synthesis when it's defined in this app (CDK's `FunctionUrlOriginAccessControl` signs with `always`, which\n   * CloudFront rejects for Web Function origins).\n   *\n   * @default - one is created per stack and signing protocol\n   */\n  readonly originAccessControl?: cloudfront.IOriginAccessControlRef;\n}\n\n/**\n * A CloudFront origin for a Web Function endpoint.\n *\n * Use `WebFunctionOrigin.withOriginAccessControl(endpoint)` for an `AWS_IAM` endpoint: CloudFront signs every request,\n * and only your distribution may call the endpoint. `new WebFunctionOrigin(endpoint)` is for a public (`NONE`) endpoint.\n */\nexport class WebFunctionOrigin extends cloudfront.OriginBase {\n  /**\n   * An origin for an `AWS_IAM` endpoint, with origin access control: CloudFront signs every request to the endpoint\n   * (`always-amz-auth`, which keeps the viewer's `Authorization` header for your application), and the function's\n   * resource policy allows `cloudfront.amazonaws.com` to call this endpoint on behalf of this distribution only.\n   *\n   * The distribution must be in the function's stack.\n   */\n  public static withOriginAccessControl(endpoint: WebFunctionEndpoint, props: WebFunctionOriginWithOacProps = {}): cloudfront.IOrigin {\n    if (endpoint.authType !== WebFunctionAuthType.AWS_IAM) {\n      throw new Error(`${endpoint.node.path}: origin access control needs an AWS_IAM endpoint (this one is ${endpoint.authType}, which Lambda doesn't authenticate); use new WebFunctionOrigin(endpoint)`);\n    }\n    if (endpoint.endpointType === WebFunctionEndpointType.MULTI_REGION) {\n      const optIn = endpoint.regions.filter((r) => OPT_IN_REGIONS.includes(r));\n      if (optIn.length > 0) {\n        throw new Error(`${endpoint.node.path}: CloudFront can't sign requests that a MULTI_REGION endpoint routes to opt-in regions (${optIn.join(', ')}); use a PER_REGION endpoint and one origin per region`);\n      }\n    }\n    return new WebFunctionOriginWithOac(endpoint, props);\n  }\n\n  private readonly props: WebFunctionOriginProps;\n\n  constructor(endpoint: WebFunctionEndpoint, props: WebFunctionOriginProps = {}) {\n    if (endpoint.authType === WebFunctionAuthType.AWS_IAM) {\n      throw new Error(`${endpoint.node.path}: CloudFront can only call an AWS_IAM endpoint with origin access control; use WebFunctionOrigin.withOriginAccessControl(endpoint)`);\n    }\n    super(originDomainName(endpoint, props.region), props);\n    validateTimeouts(endpoint, props);\n    this.validateResponseCompletionTimeoutWithReadTimeout(props.responseCompletionTimeout, props.readTimeout);\n    this.props = props;\n  }\n\n  protected renderCustomOriginConfig(): cloudfront.CfnDistribution.CustomOriginConfigProperty | undefined {\n    return customOriginConfig(this.props);\n  }\n}\n\nclass WebFunctionOriginWithOac extends cloudfront.OriginBase {\n  private readonly signingProtocol: 'sigv4' | 'sigv4a';\n\n  constructor(private readonly endpoint: WebFunctionEndpoint, private readonly props: WebFunctionOriginWithOacProps) {\n    super(originDomainName(endpoint, props.region), props);\n    validateTimeouts(endpoint, props);\n    this.validateResponseCompletionTimeoutWithReadTimeout(props.responseCompletionTimeout, props.readTimeout);\n    // The global domain routes to any of the endpoint's regions, so CloudFront signs for all of them.\n    this.signingProtocol = endpoint.endpointType === WebFunctionEndpointType.MULTI_REGION ? 'sigv4a' : 'sigv4';\n    if (props.originAccessControl) assertOriginAccessControl(endpoint, props.originAccessControl, this.signingProtocol);\n  }\n\n  public bind(scope: Construct, options: cloudfront.OriginBindOptions): cloudfront.OriginBindConfig {\n    const config = super.bind(scope, options);\n    const stack = Stack.of(scope);\n    if (stack !== Stack.of(this.endpoint)) {\n      // The resource policy names the distribution, and the distribution names the endpoint: a reference cycle.\n      throw new Error(`${scope.node.path}: a distribution with a WebFunctionOrigin must be in the function's stack (${Stack.of(this.endpoint).stackName})`);\n    }\n    if (options.distributionId === undefined) {\n      throw new Error(`${scope.node.path}: a WebFunctionOrigin with origin access control must be used by a cloudfront.Distribution (its ID scopes the resource policy)`);\n    }\n    const oac = this.props.originAccessControl ?? this.sharedOriginAccessControl(stack);\n\n    const result = this.endpoint.webFunction.addToResourcePolicy(new iam.PolicyStatement({\n      principals: [new iam.ServicePrincipal('cloudfront.amazonaws.com')],\n      actions: ['lambda:InvokeWebFunctionEndpoint'],\n      resources: [this.endpoint.endpointArn],\n      conditions: {\n        StringEquals: {\n          'aws:SourceArn': stack.formatArn({ service: 'cloudfront', region: '', resource: 'distribution', resourceName: options.distributionId }),\n        },\n      },\n    }));\n    if (!result.statementAdded) {\n      throw new Error(`${scope.node.path}: could not add CloudFront to the resource policy of ${this.endpoint.webFunction.node.path}`);\n    }\n\n    return { ...config, originProperty: { ...config.originProperty!, originAccessControlId: oac.originAccessControlRef.originAccessControlId } };\n  }\n\n  protected renderCustomOriginConfig(): cloudfront.CfnDistribution.CustomOriginConfigProperty | undefined {\n    return customOriginConfig(this.props);\n  }\n\n  /** One origin access control per stack and signing protocol, shared by the stack's Web Function origins. */\n  private sharedOriginAccessControl(scope: Stack): cloudfront.IOriginAccessControlRef {\n    const id = `WebFunctionOriginAccessControl${this.signingProtocol === 'sigv4a' ? 'SigV4a' : 'SigV4'}`;\n    const existing = scope.node.tryFindChild(id) as cloudfront.CfnOriginAccessControl | undefined;\n    if (existing) return existing;\n    const oac: cloudfront.CfnOriginAccessControl = new cloudfront.CfnOriginAccessControl(scope, id, {\n      originAccessControlConfig: {\n        // Unique in the account, like the names CDK generates for its own origin access controls.\n        name: Lazy.string({ produce: () => Names.uniqueResourceName(oac, { maxLength: 64 }) }),\n        description: `Lambda Web Function origins (${this.signingProtocol})`,\n        // The CDK enums have neither value yet. Lambda Web Function origins accept only always-amz-auth.\n        originAccessControlOriginType: 'lambda',\n        signingBehavior: 'always-amz-auth',\n        signingProtocol: this.signingProtocol,\n      },\n    });\n    return oac;\n  }\n}\n\n/**\n * Checks a given origin access control when its configuration is known (one created in this app, not imported):\n * CloudFront rejects other settings for a Web Function origin only when the distribution deploys.\n */\nfunction assertOriginAccessControl(endpoint: WebFunctionEndpoint, oac: cloudfront.IOriginAccessControlRef, protocol: string) {\n  const cfn = oac instanceof cloudfront.CfnOriginAccessControl\n    ? oac\n    : oac.node.children.find((c): c is cloudfront.CfnOriginAccessControl => c instanceof cloudfront.CfnOriginAccessControl);\n  if (cfn === undefined) return;\n  const config = Stack.of(cfn).resolve(cfn.originAccessControlConfig) as Record<string, unknown>;\n  const expected: Record<string, string> = { OriginAccessControlOriginType: 'lambda', SigningBehavior: 'always-amz-auth', SigningProtocol: protocol };\n  const wrong = Object.entries(expected).filter(([key, value]) => {\n    const actual = config[key] ?? config[key.charAt(0).toLowerCase() + key.slice(1)];\n    return typeof actual === 'string' && actual !== value;\n  });\n  if (wrong.length > 0) {\n    throw new Error(`${endpoint.node.path}: the origin access control ${oac.node.path} must have ${wrong.map(([k, v]) => `${k} '${v}'`).join(', ')} for this endpoint`);\n  }\n}\n\nfunction originDomainName(endpoint: WebFunctionEndpoint, region?: string): string {\n  if (region === undefined) return endpoint.domainName;\n  if (endpoint.endpointType !== WebFunctionEndpointType.PER_REGION) {\n    throw new Error(`${endpoint.node.path}: region is only for PER_REGION endpoints (this one is ${endpoint.endpointType})`);\n  }\n  return endpoint.regionalDomainName(region);\n}\n\nfunction validateTimeouts(endpoint: WebFunctionEndpoint, props: WebFunctionOriginProps) {\n  for (const [name, value] of [['readTimeout', props.readTimeout], ['keepaliveTimeout', props.keepaliveTimeout]] as const) {\n    const seconds = value?.toSeconds();\n    if (seconds !== undefined && !Token.isUnresolved(seconds) && (!Number.isInteger(seconds) || seconds < 1)) {\n      throw new Error(`${endpoint.node.path}: ${name} must be a whole number of seconds, at least 1, got ${seconds}`);\n    }\n  }\n}\n\nfunction customOriginConfig(props: WebFunctionOriginProps): cloudfront.CfnDistribution.CustomOriginConfigProperty {\n  return {\n    originProtocolPolicy: cloudfront.OriginProtocolPolicy.HTTPS_ONLY,\n    originSslProtocols: [cloudfront.OriginSslPolicy.TLS_V1_2],\n    originReadTimeout: props.readTimeout?.toSeconds(),\n    originKeepaliveTimeout: props.keepaliveTimeout?.toSeconds(),\n    ipAddressType: props.ipAddressType,\n  };\n}\n"]}

package/lib/web-function-revision.js

@@ -11,7 +11,7 @@ const constructs_1 = require("constructs");
  * only revisions within `revisionRetention`, or that an endpoint routes to, are kept.
  */
 class WebFunctionRevision extends constructs_1.Construct {
-    static [JSII_RTTI_SYMBOL_1] = { fqn: "@ashishpandeyone/cdk-lambda-web-function.WebFunctionRevision", version: "0.1.4" };
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "@ashishpandeyone/cdk-lambda-web-function.WebFunctionRevision", version: "0.1.6" };
     /**
      * References an existing revision of `webFunction`, e.g. to pin an endpoint to it or split traffic with it.
      */

package/lib/web-function.d.ts

@@ -127,8 +127,12 @@ export interface WebFunctionProps extends WebFunctionOptions {
 }
 /**
  * A Lambda Web Function, created in this app (`WebFunction`) or imported (`WebFunction.fromWebFunctionArn`).
+ *
+ * `addToResourcePolicy` adds to the function's resource policy (who else may call or manage it). A `WebFunction` has
+ * one, created by its stack on the first statement. An imported function's policy belongs to the stack that created
+ * it, so the statement isn't added (`statementAdded: false`).
  */
-export interface IWebFunction extends IResource, lambda.IWebFunctionRef {
+export interface IWebFunction extends IResource, lambda.IWebFunctionRef, iam.IResourceWithPolicy {
     /**
      * The function's name.
      *
@@ -145,7 +149,9 @@ export interface IWebFunction extends IResource, lambda.IWebFunctionRef {
      * Allows `grantee` to call the function's endpoint (`lambda:InvokeWebFunctionEndpoint`): the default endpoint
      * of a `WebFunction`; for an imported function, the endpoint named in its attributes, or every endpoint.
      *
-     * This adds to the grantee's IAM policy. For a function in another account, its resource policy must also allow the grantee.
+     * For a `WebFunction`, a grantee in this account gets an IAM policy statement; another account or an AWS service
+     * also gets a statement in the function's resource policy. For an imported function, only the grantee's IAM policy
+     * changes: across accounts, the function's own resource policy must also allow the grantee.
      * [disable-awslint:no-grants]
      */
     grantInvoke(grantee: iam.IGrantable): iam.Grant;
@@ -188,6 +194,37 @@ export interface WebFunctionAttributes {
      */
     readonly endpointName?: string;
 }
+/**
+ * Permission for a principal outside this account, an AWS service or an organization to call a function's endpoints.
+ */
+export interface WebFunctionPermission {
+    /**
+     * Who may call: an account (`iam.AccountPrincipal`), a role or user (`iam.ArnPrincipal`), an AWS service
+     * (`iam.ServicePrincipal`, with `sourceArn` or `sourceAccount`) or an organization (`iam.OrganizationPrincipal`).
+     *
+     * A principal in another account also needs `lambda:InvokeWebFunctionEndpoint` in its own IAM policy.
+     */
+    readonly principal: iam.IPrincipal;
+    /**
+     * The endpoint the principal may call. It must belong to this function.
+     *
+     * @default - every endpoint of the function, including ones added later
+     */
+    readonly endpoint?: WebFunctionEndpoint;
+    /**
+     * For an AWS service: the ARN of the resource calling on its behalf (condition `aws:SourceArn`, `ArnLike`),
+     * e.g. a CloudFront distribution. Without it or `sourceAccount`, any account's use of the service could call the endpoint.
+     *
+     * @default - no condition
+     */
+    readonly sourceArn?: string;
+    /**
+     * For an AWS service: the account that owns the resource calling on its behalf (condition `aws:SourceAccount`).
+     *
+     * @default - no condition
+     */
+    readonly sourceAccount?: string;
+}
 /**
  * What `WebFunction` and imported functions have in common.
  */
@@ -201,6 +238,10 @@ export declare abstract class WebFunctionBase extends Resource implements IWebFu
      * [disable-awslint:no-grants]
      */
     abstract grantInvoke(grantee: iam.IGrantable): iam.Grant;
+    /**
+     * Adds a statement to the function's resource policy (not added for an imported function).
+     */
+    abstract addToResourcePolicy(statement: iam.PolicyStatement): iam.AddToResourcePolicyResult;
     /**
      * A metric of this function's execution environments in `AWS/Lambda/Web` (dimension `FunctionName`), across all endpoints.
      * For request and error counts, use the endpoint's metrics (`fn.endpoint.metricRequests()`).
@@ -281,6 +322,8 @@ export declare class WebFunction extends WebFunctionBase implements iam.IGrantab
     private readonly logOptions;
     private readonly resource;
     private readonly revisionCleanup;
+    private readonly permissionIds;
+    private resourcePolicy?;
     constructor(scope: Construct, id: string, props: WebFunctionProps);
     /**
      * Adds an endpoint (up to 10 per function), e.g. a public one next to an IAM-only one, or one pinned to an
@@ -302,6 +345,23 @@ export declare class WebFunction extends WebFunctionBase implements iam.IGrantab
      * [disable-awslint:no-grants]
      */
     grantInvoke(grantee: iam.IGrantable): iam.Grant;
+    /**
+     * Allows a principal in another account, an AWS service or an organization to call the function's endpoints,
+     * through the function's resource policy. For a role in this account, use `grantInvoke`.
+     *
+     * @param id the statement ID (`Sid`): letters and digits, unique within the function
+     */
+    addPermission(id: string, permission: WebFunctionPermission): void;
+    /**
+     * Adds a statement to the function's resource policy, e.g. to let another account manage the function.
+     * For invoking, prefer `addPermission` or `grantInvoke`.
+     *
+     * The function has one resource policy (`AWS::Lambda::ResourcePolicy`), created on the first statement. This stack
+     * is its only writer: another stack or template can't also attach one, and changes made outside CloudFormation
+     * are overwritten by the next update of the policy.
+     */
+    addToResourcePolicy(statement: iam.PolicyStatement): iam.AddToResourcePolicyResult;
+    private createResourcePolicy;
     private createEndpoint;
     private createLogGroups;
     private logGroupIn;