@ashishpandeyone/cdk-lambda-web-function 0.1.1 → 0.1.3

package/lib/web-function-endpoint.js

@@ -37,20 +37,25 @@ exports.WebFunctionEndpoint = void 0;
 const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
 const node_crypto_1 = require("node:crypto");
 const aws_cdk_lib_1 = require("aws-cdk-lib");
+const cloudwatch = __importStar(require("aws-cdk-lib/aws-cloudwatch"));
 const lambda = __importStar(require("aws-cdk-lib/aws-lambda"));
 const constructs_1 = require("constructs");
 const enums_1 = require("./enums");
 const endpoint_lookup_1 = require("./private/endpoint-lookup");
+const metrics_1 = require("./private/metrics");
+const regional_alarm_1 = require("./private/regional-alarm");
+const traffic_shift_1 = require("./private/traffic-shift");
 const validation_1 = require("./private/validation");
+const web_function_grants_1 = require("./web-function-grants");
 /**
- * The HTTPS endpoint of a Web Function. Created by `WebFunction`; access it as `fn.endpoint`.
+ * An HTTPS endpoint of a Web Function: `fn.endpoint` (the default one) or the result of `fn.addEndpoint()`.
  *
- * Only `WebFunction` creates endpoints in this version (one per function), so the constructor is private.
+ * Endpoints are created only through `WebFunction`, which owns their log groups in every region, so the constructor is private.
  */
 class WebFunctionEndpoint extends constructs_1.Construct {
-    static [JSII_RTTI_SYMBOL_1] = { fqn: "@ashishpandeyone/cdk-lambda-web-function.WebFunctionEndpoint", version: "0.1.1" };
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "@ashishpandeyone/cdk-lambda-web-function.WebFunctionEndpoint", version: "0.1.3" };
     /**
-     * Creates the endpoint of a Web Function. Used by `WebFunction`.
+     * Creates an endpoint of a Web Function. Used by `WebFunction`.
      *
      * @internal
      */
@@ -63,6 +68,8 @@ class WebFunctionEndpoint extends constructs_1.Construct {
     endpointArn;
     /** Where the endpoint serves traffic from. */
     endpointType;
+    /** How callers of the endpoint are authenticated. */
+    authType;
     /** Every region the endpoint serves from: the home region first, then the others in alphabetical order. */
     regions;
     /**
@@ -73,15 +80,27 @@ class WebFunctionEndpoint extends constructs_1.Construct {
      * The endpoint's URL: the global URL for `MULTI_REGION`, otherwise the home region's.
      */
     url;
+    /** Grants on this endpoint (e.g. `grants.invoke(principal)`). */
+    grants;
+    /**
+     * The alarms this endpoint created for its deployment's `rollbackOn`, one per threshold in every region it serves from
+     * (the home region's first). Empty without `rollbackOn`.
+     */
+    rollbackAlarms = [];
     homeRegion;
-    functionName;
-    functionArn;
+    webFunction;
+    resource;
+    weights;
+    routed = false;
+    gradual;
     lookup;
     constructor(scope, id, props) {
         super(scope, id);
         const homeRegion = aws_cdk_lib_1.Stack.of(this).region;
         const endpointType = props.endpointType ?? enums_1.WebFunctionEndpointType.HOME_REGION;
         const extraRegions = normaliseRegions(this, endpointType, homeRegion, props.regions ?? []);
+        validateRateLimit(this, props.rateLimit);
+        validateMaxEnvironments(this, props.maxEnvironments);
         if (props.endpointName !== undefined) {
             (0, validation_1.assertResourceName)(this, 'endpointName', props.endpointName);
             aws_cdk_lib_1.Annotations.of(this).addWarningV2('@cdk-lambda-web:explicitEndpointName', `endpointName '${props.endpointName}' is set explicitly: changing endpointType or regions later also requires a new endpointName, otherwise the deployment fails with "already exists" (the stack rolls back safely). Omit endpointName to get a name that changes automatically.`);
@@ -90,23 +109,65 @@ class WebFunctionEndpoint extends constructs_1.Construct {
             aws_cdk_lib_1.Annotations.of(this).addWarningV2('@cdk-lambda-web:authTypeNone', 'authType NONE makes the endpoint public: Lambda does no authentication, so your application must authenticate requests itself.');
         }
         this.endpointType = endpointType;
-        this.endpointName = props.endpointName ?? defaultEndpointName(endpointType, extraRegions);
+        this.authType = props.authType;
+        this.endpointName = props.endpointName ?? defaultEndpointName(props.namePrefix, props.nameSeed, endpointType, extraRegions);
         this.regions = [homeRegion, ...extraRegions];
         this.homeRegion = homeRegion;
-        this.functionName = props.functionName;
-        this.functionArn = props.functionArn;
+        this.webFunction = props.webFunction;
+        this.weights = [{ revisionId: props.currentRevision.revisionId, weight: 100 }];
         const resource = new lambda.CfnWebFunctionEndpoint(this, 'Resource', {
-            functionName: props.functionArn,
+            functionName: props.webFunction.webFunctionArn,
             endpointName: this.endpointName,
             endpointType,
             authType: props.authType,
+            description: props.description,
             regions: extraRegions.length > 0 ? extraRegions : undefined,
-            revisionWeights: [{ revisionId: props.revisionId, weight: 100 }],
+            revisionWeights: this.weights,
+            throttleConfig: props.rateLimit !== undefined ? { rateLimit: props.rateLimit } : undefined,
+            scalingConfig: props.maxEnvironments !== undefined ? { maxEnvironments: props.maxEnvironments } : undefined,
         });
         aws_cdk_lib_1.Validations.of(resource).acknowledge(validation_1.CFN_VALIDATE_UNKNOWN_TYPE);
+        this.resource = resource;
+        this.gradual = props.deployment?._gradual ?? false;
+        if (props.deployment?._gradual) {
+            if (props.revision !== undefined || props.additionalRevisions !== undefined) {
+                throw new Error(`${this.node.path}: an endpoint with a ${props.deployment._kind} deployment always moves to the current revision; it can't also set revision or additionalRevisions`);
+            }
+            const rollbackAlarmArns = props.deployment._rollbackOn ? this.createRollbackAlarms(props.deployment._rollbackOn) : [];
+            const waitSeconds = props.deployment._waitSeconds;
+            const rollback = props.deployment._rollbackOn;
+            if (rollback && waitSeconds < rollback.period.toSeconds() * rollback.evaluationPeriods + 120) {
+                aws_cdk_lib_1.Annotations.of(this).addWarningV2('@cdk-lambda-web:rollbackSlowerThanStep', `rollbackOn needs ${rollback.evaluationPeriods} period(s) of ${rollback.period.toHumanString()} plus about 2 minutes of CloudWatch delay to fire, longer than each ${props.deployment._kind} step (${aws_cdk_lib_1.Duration.seconds(waitSeconds).toHumanString()}): a bad revision can reach the next step before its alarm fires.`);
+            }
+            // Moves the traffic in steps before CloudFormation writes the endpoint, which then finds it already done.
+            const shift = new traffic_shift_1.TrafficShift(this, 'Deployment', {
+                functionName: props.webFunction.webFunctionName,
+                functionArn: props.webFunction.webFunctionArn,
+                endpointName: this.endpointName,
+                revisionId: props.currentRevision.revisionId,
+                deployment: props.deployment,
+                alarmArns: rollbackAlarmArns,
+                endpointConfig: {
+                    endpointType,
+                    authType: props.authType,
+                    description: props.description,
+                    regions: extraRegions,
+                    rateLimit: props.rateLimit,
+                    maxEnvironments: props.maxEnvironments,
+                },
+            });
+            resource.node.addDependency(shift);
+            // Alarms in other regions are only referenced by ARN.
+            for (const alarm of this.node.findAll().filter((c) => c instanceof regional_alarm_1.RegionalAlarm))
+                shift.node.addDependency(alarm);
+        }
+        if (props.revision !== undefined || props.additionalRevisions !== undefined) {
+            this.routeTraffic(props.revision ?? props.currentRevision, props.additionalRevisions);
+        }
         this.endpointArn = resource.attrEndpointArn;
         this.domainName = resource.attrDomainName;
         this.url = `https://${resource.attrDomainName}`;
+        this.grants = web_function_grants_1.WebFunctionGrants._forEndpoint(this);
     }
     /**
      * The URL of this endpoint in one region. Only for `PER_REGION` endpoints.
@@ -124,13 +185,183 @@ class WebFunctionEndpoint extends constructs_1.Construct {
             return this.url;
         }
         this.lookup ??= new endpoint_lookup_1.EndpointLookup(this, 'Lookup', {
-            functionName: this.functionName,
-            functionArn: this.functionArn,
+            functionName: this.webFunction.webFunctionName,
+            functionArn: this.webFunction.webFunctionArn,
             endpointName: this.endpointName,
             endpointArn: this.endpointArn,
         });
         return `https://${this.lookup.regionalDomain(region)}`;
     }
+    /**
+     * Routes the endpoint to `revision` instead of the function's current revision, optionally sharing
+     * traffic with one more revision (`additionalRevisions`, which gets its weight; `revision` gets the rest).
+     *
+     * Use it to keep an endpoint on an earlier revision (`WebFunctionRevision.fromRevisionAttributes`),
+     * or to send part of the traffic to the current revision:
+     * `fn.endpoint.routeTraffic(previous, [{ revision: fn.currentRevision, weight: 0.1 }])`.
+     * Can be called once per endpoint, and not on one created with `revision` or `additionalRevisions`.
+     */
+    routeTraffic(revision, additionalRevisions) {
+        if (this.gradual) {
+            throw new Error(`${this.node.path}: the endpoint has a deployment in steps, which always moves it to the current revision; routeTraffic() can't be used with it`);
+        }
+        if (this.routed) {
+            throw new Error(`${this.node.path}: the endpoint's revisions are already set (revision, additionalRevisions or routeTraffic)`);
+        }
+        this.weights = revisionWeights(this, this.webFunction, revision, additionalRevisions ?? []);
+        this.resource.revisionWeights = this.weights;
+        this.routed = true;
+    }
+    /**
+     * The IDs of the revisions this endpoint routes to.
+     *
+     * @internal
+     */
+    _revisionIds() {
+        return this.weights.map((w) => w.revisionId);
+    }
+    /**
+     * A metric of this endpoint in `AWS/Lambda/Web` (dimensions `FunctionName` and `EndpointName`).
+     *
+     * Metrics are published in the region that served the request: pass `region` for one of the endpoint's
+     * other regions. An alarm can only use metrics from its own stack's region.
+     *
+     * @default - sum over 1 minute, in the home region
+     */
+    metric(metricName, props) {
+        return new cloudwatch.Metric({
+            namespace: metrics_1.WEB_NAMESPACE,
+            metricName,
+            dimensionsMap: (0, metrics_1.endpointDimensions)(this.metricIds()),
+            statistic: cloudwatch.Stats.SUM,
+            period: metrics_1.DEFAULT_PERIOD,
+            ...props,
+        });
+    }
+    /** Requests the endpoint served (`ExecutedRequests`). There's no separate count of successful (2XX) responses. */
+    metricRequests(props) {
+        return this.metric(metrics_1.REQUESTS, props);
+    }
+    /**
+     * Requests answered with a 4XX status (`HTTPResponseStatusClass4XX`), including 429s from `rateLimit` and `maxEnvironments`.
+     * The metric only exists once it's non-zero, so alarms should treat missing data as not breaching.
+     */
+    metricClientErrors(props) {
+        return this.metric(metrics_1.CLIENT_ERRORS, props);
+    }
+    /**
+     * Requests answered with a 5XX status (`HTTPResponseStatusClass5XX`). Includes the platform's 503s while the endpoint
+     * scales up for a sudden burst, not only your application's errors. The metric only exists once it's non-zero.
+     */
+    metricServerErrors(props) {
+        return this.metric(metrics_1.SERVER_ERRORS, props);
+    }
+    /** The percentage of requests answered with a 4XX status (math expression; periods with no 4XX count as 0). */
+    metricClientErrorRate(props) {
+        return this.rate(metrics_1.CLIENT_ERRORS, 'Client error rate (%)', props);
+    }
+    /** The percentage of requests answered with a 5XX status (math expression; periods with no 5XX count as 0). */
+    metricServerErrorRate(props) {
+        return this.rate(metrics_1.SERVER_ERRORS, 'Server error rate (%)', props);
+    }
+    /**
+     * Execution environments serving the endpoint (`EndpointActiveEnvironments`), to compare with `maxEnvironments`.
+     *
+     * @default - maximum over 1 minute, in the home region
+     */
+    metricActiveEnvironments(props) {
+        return this.usageMetric('EndpointActiveEnvironments', cloudwatch.Stats.MAXIMUM, props);
+    }
+    /** Requests rejected with 429 because the endpoint reached its `rateLimit` (`EndpointRequestThrottles`). */
+    metricRequestThrottles(props) {
+        return this.usageMetric('EndpointRequestThrottles', cloudwatch.Stats.SUM, props);
+    }
+    /** Requests rejected with 429 because the endpoint reached `maxEnvironments` (`EndpointActiveEnvironmentThrottles`). */
+    metricEnvironmentThrottles(props) {
+        return this.usageMetric('EndpointActiveEnvironmentThrottles', cloudwatch.Stats.SUM, props);
+    }
+    /**
+     * Allows `grantee` to call this endpoint. Shortcut for `grants.invoke(grantee)`.
+     * [disable-awslint:no-grants]
+     */
+    grantInvoke(grantee) {
+        return this.grants.invoke(grantee);
+    }
+    metricIds() {
+        return { functionName: this.webFunction.webFunctionName, endpointName: this.endpointName };
+    }
+    rate(errorMetric, label, props) {
+        const period = props?.period ?? metrics_1.DEFAULT_PERIOD;
+        const options = { period, region: props?.region, account: props?.account };
+        return new cloudwatch.MathExpression({
+            expression: (0, metrics_1.rateExpression)(1),
+            usingMetrics: { requests: this.metric(metrics_1.REQUESTS, options), errors: this.metric(errorMetric, options) },
+            period,
+            label: props?.label ?? label,
+        });
+    }
+    usageMetric(metricName, statistic, props) {
+        return new cloudwatch.Metric({
+            namespace: metrics_1.USAGE_NAMESPACE,
+            metricName,
+            dimensionsMap: { ...(0, metrics_1.endpointDimensions)(this.metricIds()), ExecutionRegion: props?.region ?? this.homeRegion },
+            statistic,
+            period: metrics_1.DEFAULT_PERIOD,
+            ...props,
+        });
+    }
+    /** One alarm per threshold in every serving region: a CloudFormation alarm at home, a custom resource elsewhere. Returns their ARNs. */
+    createRollbackAlarms(rollback) {
+        const thresholds = [
+            { key: 'ServerErrors', short: '5xx', metric: metrics_1.SERVER_ERRORS, status: '5XX', threshold: rollback.serverErrorRate },
+            { key: 'ClientErrors', short: '4xx', metric: metrics_1.CLIENT_ERRORS, status: '4XX', threshold: rollback.clientErrorRate },
+        ];
+        const arns = [];
+        for (const t of thresholds) {
+            if (t.threshold === undefined)
+                continue;
+            for (const region of this.regions) {
+                const description = `Rolls back deployments of endpoint ${this.endpointName} of ${this.webFunction.webFunctionName} when more than `
+                    + `${t.threshold}% of its requests in ${region} get a ${t.status} response (${rollback.evaluationPeriods} x ${rollback.period.toHumanString()}, `
+                    + `periods with fewer than ${rollback.minimumRequests} requests ignored).`;
+                if (region === this.homeRegion) {
+                    const alarm = new cloudwatch.Alarm(this, `Rollback${t.key}`, {
+                        metric: new cloudwatch.MathExpression({
+                            expression: (0, metrics_1.rateExpression)(rollback.minimumRequests),
+                            usingMetrics: {
+                                requests: this.metric(metrics_1.REQUESTS, { period: rollback.period }),
+                                errors: this.metric(t.metric, { period: rollback.period }),
+                            },
+                            period: rollback.period,
+                            label: `${t.status} rate (%)`,
+                        }),
+                        threshold: t.threshold,
+                        evaluationPeriods: rollback.evaluationPeriods,
+                        comparisonOperator: cloudwatch.ComparisonOperator.GREATER_THAN_THRESHOLD,
+                        treatMissingData: cloudwatch.TreatMissingData.NOT_BREACHING,
+                        alarmDescription: description,
+                    });
+                    this.rollbackAlarms.push(alarm);
+                    arns.push(alarm.alarmArn);
+                }
+                else {
+                    const alarm = new regional_alarm_1.RegionalAlarm(this, `Rollback${t.key}-${region}`, {
+                        region,
+                        alarmName: `${regional_alarm_1.ALARM_NAME_PREFIX}${this.webFunction.webFunctionName}-${this.endpointName}-${t.short}-rate`,
+                        alarmDescription: description,
+                        metrics: (0, metrics_1.rateAlarmQueries)(this.metricIds(), t.metric, rollback.period, rollback.minimumRequests),
+                        threshold: t.threshold,
+                        evaluationPeriods: rollback.evaluationPeriods,
+                        comparisonOperator: cloudwatch.ComparisonOperator.GREATER_THAN_THRESHOLD,
+                        treatMissingData: cloudwatch.TreatMissingData.NOT_BREACHING,
+                    });
+                    this.rollbackAlarms.push(cloudwatch.Alarm.fromAlarmArn(this, `Rollback${t.key}-${region}-Ref`, alarm.alarmArn));
+                    arns.push(alarm.alarmArn);
+                }
+            }
+        }
+        return arns;
+    }
 }
 exports.WebFunctionEndpoint = WebFunctionEndpoint;
 function normaliseRegions(scope, endpointType, homeRegion, regions) {
@@ -156,9 +387,52 @@ function normaliseRegions(scope, endpointType, homeRegion, regions) {
     }
     return extra;
 }
-/** `default-<hash>`: a type or region change produces a new name, so the replacement doesn't collide. */
-function defaultEndpointName(endpointType, extraRegions) {
-    const hash = (0, node_crypto_1.createHash)('sha256').update([endpointType, ...extraRegions].join(',')).digest('hex').slice(0, 8);
-    return `default-${hash}`;
+function validateRateLimit(scope, rateLimit) {
+    if (rateLimit === undefined || aws_cdk_lib_1.Token.isUnresolved(rateLimit))
+        return;
+    const allowed = rateLimit === 0
+        || (rateLimit >= 100 && rateLimit <= 1000 && rateLimit % 100 === 0)
+        || (rateLimit >= 2000 && rateLimit <= 10000 && rateLimit % 1000 === 0);
+    if (!allowed) {
+        throw new Error(`${scope.node.path}: rateLimit must be 0, 100-1,000 in steps of 100, or 2,000-10,000 in steps of 1,000, got ${rateLimit}`);
+    }
+}
+function validateMaxEnvironments(scope, maxEnvironments) {
+    if (maxEnvironments === undefined || aws_cdk_lib_1.Token.isUnresolved(maxEnvironments))
+        return;
+    if (!Number.isInteger(maxEnvironments) || maxEnvironments < 2 || maxEnvironments > 10000) {
+        throw new Error(`${scope.node.path}: maxEnvironments must be an integer from 2 to 10,000, got ${maxEnvironments}`);
+    }
+}
+/** `primary` gets what `additional` leaves; weights are whole percentages summing to 100. */
+function revisionWeights(scope, webFunction, primary, additional) {
+    for (const r of [primary, ...additional.map((a) => a.revision)]) {
+        if (r.webFunction !== webFunction) {
+            throw new Error(`${scope.node.path}: revision ${r.revisionId} belongs to another function`);
+        }
+    }
+    if (additional.length === 0) {
+        return [{ revisionId: primary.revisionId, weight: 100 }];
+    }
+    if (additional.length > 1) {
+        throw new Error(`${scope.node.path}: an endpoint routes to at most two revisions, so additionalRevisions takes one`);
+    }
+    const [{ revision, weight }] = additional;
+    const percent = Math.round(weight * 100);
+    if (aws_cdk_lib_1.Token.isUnresolved(weight) || Math.abs(weight * 100 - percent) > 1e-9 || percent < 1 || percent > 99) {
+        throw new Error(`${scope.node.path}: an additional revision's weight must be a whole percentage from 0.01 to 0.99, got ${weight}`);
+    }
+    if (revision === primary || (!aws_cdk_lib_1.Token.isUnresolved(revision.revisionId) && revision.revisionId === primary.revisionId)) {
+        throw new Error(`${scope.node.path}: the additional revision is the same as the endpoint's revision`);
+    }
+    return [{ revisionId: primary.revisionId, weight: 100 - percent }, { revisionId: revision.revisionId, weight: percent }];
+}
+/**
+ * `<prefix>-<hash>`, with the hash covering the endpoint type and regions: a type or region change produces
+ * a new name, so the replacement doesn't collide with the endpoint it replaces.
+ */
+function defaultEndpointName(prefix, seed, endpointType, extraRegions) {
+    const hash = (0, node_crypto_1.createHash)('sha256').update([...(seed !== undefined ? [seed] : []), endpointType, ...extraRegions].join(',')).digest('hex').slice(0, 8);
+    return `${prefix}-${hash}`;
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"web-function-endpoint.js","sourceRoot":"","sources":["../src/web-function-endpoint.ts"],"names":[],"mappings":"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","sourcesContent":["import { createHash } from 'node:crypto';\nimport { Annotations, Stack, Token, Validations } from 'aws-cdk-lib';\nimport * as lambda from 'aws-cdk-lib/aws-lambda';\nimport { Construct } from 'constructs';\nimport { WebFunctionAuthType, WebFunctionEndpointType } from './enums';\nimport { EndpointLookup } from './private/endpoint-lookup';\nimport { CFN_VALIDATE_UNKNOWN_TYPE, assertResourceName } from './private/validation';\n\n/**\n * Options for a Web Function's endpoint.\n */\nexport interface WebFunctionEndpointOptions {\n  /**\n   * Where the endpoint serves traffic from.\n   *\n   * @default WebFunctionEndpointType.HOME_REGION\n   */\n  readonly endpointType?: WebFunctionEndpointType;\n\n  /**\n   * Regions to serve from in addition to the home region (the stack's region).\n   * Required (at least one) for `MULTI_REGION` and `PER_REGION`; must be empty for `HOME_REGION`.\n   *\n   * Changing this creates a new endpoint with a new URL.\n   *\n   * @default - no extra regions\n   */\n  readonly regions?: string[];\n\n  /**\n   * The endpoint's name, shown in logs (`endpointName`) and in the `lambda-web-endpoint-name` header.\n   *\n   * When omitted, the name is `default-<hash>`, with the hash covering the endpoint type and regions,\n   * so changing either deploys a new endpoint cleanly. When set, changing the endpoint type or\n   * regions also requires a new name: two endpoints of one function can't share a name, and\n   * CloudFormation creates the replacement before deleting the old one.\n   *\n   * @default - `default-<hash of type and regions>`\n   */\n  readonly endpointName?: string;\n}\n\n/**\n * Internal: how `WebFunction` creates its endpoint. Not part of the public API.\n */\ninterface WebFunctionEndpointProps extends WebFunctionEndpointOptions {\n  /** Literal name of the Web Function (the provider's IAM must not reference resource attributes). */\n  readonly functionName: string;\n\n  /** The Web Function's ARN. */\n  readonly functionArn: string;\n\n  /** ID of the revision the endpoint serves. */\n  readonly revisionId: string;\n\n  /** How callers are authenticated. */\n  readonly authType: WebFunctionAuthType;\n}\n\n/**\n * The HTTPS endpoint of a Web Function. Created by `WebFunction`; access it as `fn.endpoint`.\n *\n * Only `WebFunction` creates endpoints in this version (one per function), so the constructor is private.\n */\nexport class WebFunctionEndpoint extends Construct {\n  /**\n   * Creates the endpoint of a Web Function. Used by `WebFunction`.\n   *\n   * @internal\n   */\n  public static _create(scope: Construct, id: string, props: WebFunctionEndpointProps): WebFunctionEndpoint {\n    return new WebFunctionEndpoint(scope, id, props);\n  }\n\n  /** The endpoint's name. */\n  public readonly endpointName: string;\n\n  /** The endpoint's ARN. */\n  public readonly endpointArn: string;\n\n  /** Where the endpoint serves traffic from. */\n  public readonly endpointType: WebFunctionEndpointType;\n\n  /** Every region the endpoint serves from: the home region first, then the others in alphabetical order. */\n  public readonly regions: string[];\n\n  /**\n   * The endpoint's domain name: the global domain for `MULTI_REGION`, otherwise the home region's.\n   */\n  public readonly domainName: string;\n\n  /**\n   * The endpoint's URL: the global URL for `MULTI_REGION`, otherwise the home region's.\n   */\n  public readonly url: string;\n\n  private readonly homeRegion: string;\n  private readonly functionName: string;\n  private readonly functionArn: string;\n  private lookup?: EndpointLookup;\n\n  private constructor(scope: Construct, id: string, props: WebFunctionEndpointProps) {\n    super(scope, id);\n\n    const homeRegion = Stack.of(this).region;\n    const endpointType = props.endpointType ?? WebFunctionEndpointType.HOME_REGION;\n    const extraRegions = normaliseRegions(this, endpointType, homeRegion, props.regions ?? []);\n\n    if (props.endpointName !== undefined) {\n      assertResourceName(this, 'endpointName', props.endpointName);\n      Annotations.of(this).addWarningV2('@cdk-lambda-web:explicitEndpointName',\n        `endpointName '${props.endpointName}' is set explicitly: changing endpointType or regions later also requires a new endpointName, otherwise the deployment fails with \"already exists\" (the stack rolls back safely). Omit endpointName to get a name that changes automatically.`);\n    }\n    if (props.authType === WebFunctionAuthType.NONE) {\n      Annotations.of(this).addWarningV2('@cdk-lambda-web:authTypeNone',\n        'authType NONE makes the endpoint public: Lambda does no authentication, so your application must authenticate requests itself.');\n    }\n\n    this.endpointType = endpointType;\n    this.endpointName = props.endpointName ?? defaultEndpointName(endpointType, extraRegions);\n    this.regions = [homeRegion, ...extraRegions];\n    this.homeRegion = homeRegion;\n    this.functionName = props.functionName;\n    this.functionArn = props.functionArn;\n\n    const resource = new lambda.CfnWebFunctionEndpoint(this, 'Resource', {\n      functionName: props.functionArn,\n      endpointName: this.endpointName,\n      endpointType,\n      authType: props.authType,\n      regions: extraRegions.length > 0 ? extraRegions : undefined,\n      revisionWeights: [{ revisionId: props.revisionId, weight: 100 }],\n    });\n    Validations.of(resource).acknowledge(CFN_VALIDATE_UNKNOWN_TYPE);\n\n    this.endpointArn = resource.attrEndpointArn;\n    this.domainName = resource.attrDomainName;\n    this.url = `https://${resource.attrDomainName}`;\n  }\n\n  /**\n   * The URL of this endpoint in one region. Only for `PER_REGION` endpoints.\n   *\n   * @param region one of `regions`\n   */\n  public regionalUrl(region: string): string {\n    if (this.endpointType !== WebFunctionEndpointType.PER_REGION) {\n      throw new Error(`${this.node.path}: regionalUrl() is only available for PER_REGION endpoints (this one is ${this.endpointType}); use url`);\n    }\n    if (!this.regions.includes(region)) {\n      throw new Error(`${this.node.path}: region ${region} is not one of the endpoint's regions (${this.regions.join(', ')})`);\n    }\n    if (region === this.homeRegion) {\n      return this.url;\n    }\n    this.lookup ??= new EndpointLookup(this, 'Lookup', {\n      functionName: this.functionName,\n      functionArn: this.functionArn,\n      endpointName: this.endpointName,\n      endpointArn: this.endpointArn,\n    });\n    return `https://${this.lookup.regionalDomain(region)}`;\n  }\n}\n\nfunction normaliseRegions(scope: Construct, endpointType: WebFunctionEndpointType, homeRegion: string, regions: string[]): string[] {\n  const extra = [...new Set(regions)].filter((r) => r !== homeRegion).sort();\n  for (const r of regions) {\n    if (Token.isUnresolved(r)) {\n      throw new Error(`${scope.node.path}: regions must be literal region names, got a token`);\n    }\n    if (!/^[a-z]{2}(-[a-z]+)+-\\d$/.test(r)) {\n      throw new Error(`${scope.node.path}: '${r}' is not a valid region name`);\n    }\n  }\n  if (endpointType === WebFunctionEndpointType.HOME_REGION && extra.length > 0) {\n    throw new Error(`${scope.node.path}: a HOME_REGION endpoint serves only the home region (${homeRegion}); use MULTI_REGION or PER_REGION to add ${extra.join(', ')}`);\n  }\n  if (endpointType !== WebFunctionEndpointType.HOME_REGION) {\n    if (Token.isUnresolved(homeRegion)) {\n      throw new Error(`${scope.node.path}: ${endpointType} endpoints need a stack with an explicit region (env.region)`);\n    }\n    if (extra.length === 0) {\n      throw new Error(`${scope.node.path}: a ${endpointType} endpoint needs at least one region besides the home region (${homeRegion})`);\n    }\n  }\n  return extra;\n}\n\n/** `default-<hash>`: a type or region change produces a new name, so the replacement doesn't collide. */\nfunction defaultEndpointName(endpointType: WebFunctionEndpointType, extraRegions: string[]): string {\n  const hash = createHash('sha256').update([endpointType, ...extraRegions].join(',')).digest('hex').slice(0, 8);\n  return `default-${hash}`;\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"web-function-endpoint.js","sourceRoot":"","sources":["../src/web-function-endpoint.ts"],"names":[],"mappings":"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","sourcesContent":["import { createHash } from 'node:crypto';\nimport { Annotations, Duration, Stack, Token, Validations } from 'aws-cdk-lib';\nimport * as cloudwatch from 'aws-cdk-lib/aws-cloudwatch';\nimport * as iam from 'aws-cdk-lib/aws-iam';\nimport * as lambda from 'aws-cdk-lib/aws-lambda';\nimport { Construct } from 'constructs';\nimport { WebFunctionAuthType, WebFunctionEndpointType } from './enums';\nimport { EndpointLookup } from './private/endpoint-lookup';\nimport {\n  CLIENT_ERRORS, DEFAULT_PERIOD, REQUESTS, SERVER_ERRORS, USAGE_NAMESPACE, WEB_NAMESPACE,\n  endpointDimensions, rateAlarmQueries, rateExpression,\n} from './private/metrics';\nimport { ALARM_NAME_PREFIX, RegionalAlarm } from './private/regional-alarm';\nimport type { ResolvedRollbackOptions } from './private/rollback';\nimport { TrafficShift } from './private/traffic-shift';\nimport { CFN_VALIDATE_UNKNOWN_TYPE, assertResourceName } from './private/validation';\nimport type { IWebFunction } from './web-function';\nimport type { WebFunctionDeployment } from './web-function-deployment';\nimport { WebFunctionGrants } from './web-function-grants';\nimport type { IWebFunctionRevision } from './web-function-revision';\n\n/**\n * A revision and the share of an endpoint's traffic it receives.\n */\nexport interface WebFunctionRevisionWeight {\n  /** The revision. */\n  readonly revision: IWebFunctionRevision;\n\n  /**\n   * The revision's share of the endpoint's traffic, as a fraction (like `lambda.Alias` `additionalVersions`).\n   * Must be a whole percentage from 0.01 to 0.99.\n   */\n  readonly weight: number;\n}\n\n/**\n * Options for a Web Function's endpoint.\n */\nexport interface WebFunctionEndpointOptions {\n  /**\n   * Where the endpoint serves traffic from.\n   *\n   * @default WebFunctionEndpointType.HOME_REGION\n   */\n  readonly endpointType?: WebFunctionEndpointType;\n\n  /**\n   * Regions to serve from in addition to the home region (the stack's region).\n   * Required (at least one) for `MULTI_REGION` and `PER_REGION`; must be empty for `HOME_REGION`.\n   *\n   * Changing this creates a new endpoint with a new URL.\n   *\n   * @default - no extra regions\n   */\n  readonly regions?: string[];\n\n  /**\n   * The endpoint's name, shown in logs (`endpointName`) and in the `lambda-web-endpoint-name` header.\n   * Names are unique per function.\n   *\n   * When omitted, the name ends in a hash of the endpoint type and regions, so changing either deploys\n   * a new endpoint cleanly. When set, changing the endpoint type or regions also requires a new name:\n   * two endpoints of one function can't share a name, and CloudFormation creates the replacement\n   * before deleting the old one.\n   *\n   * @default - `default-<hash>` for the function's default endpoint, `<id>-<hash>` for endpoints added with `addEndpoint`\n   */\n  readonly endpointName?: string;\n\n  /**\n   * A description of the endpoint.\n   *\n   * @default - no description\n   */\n  readonly description?: string;\n\n  /**\n   * The most requests per second the endpoint accepts; excess requests get HTTP 429.\n   * Allowed: 0 (blocks all traffic), 100–1,000 in steps of 100, or 2,000–10,000 in steps of 1,000.\n   *\n   * Enforced separately in each region the endpoint serves from, so a multi-region endpoint\n   * can accept this many requests per second in every region.\n   *\n   * @default - no limit beyond the service quota of 10,000 requests per second per endpoint (per region)\n   */\n  readonly rateLimit?: number;\n\n  /**\n   * The most execution environments the endpoint may use (2–10,000). Each one uses 2 vCPUs of the account's quota.\n   *\n   * Enforced separately in each region the endpoint serves from.\n   *\n   * @default - scales within the account's vCPU quota\n   */\n  readonly maxEnvironments?: number;\n\n  /**\n   * How the endpoint moves its traffic to a new revision: all at once, or in steps\n   * (`WebFunctionDeployment.canary()` or `linear()`) that watch CloudWatch alarms and move\n   * the traffic back when one goes into ALARM.\n   *\n   * A deployment in steps can't be combined with `revision`, `additionalRevisions` or `routeTraffic()`.\n   *\n   * @default WebFunctionDeployment.allAtOnce()\n   */\n  readonly deployment?: WebFunctionDeployment;\n}\n\n/**\n * Options for `WebFunction.addEndpoint`.\n */\nexport interface AddWebFunctionEndpointOptions extends WebFunctionEndpointOptions {\n  /**\n   * How callers of this endpoint are authenticated.\n   */\n  readonly authType: WebFunctionAuthType;\n\n  /**\n   * The revision the endpoint serves, e.g. an earlier one from `WebFunctionRevision.fromRevisionAttributes`\n   * to keep this endpoint on it while others move on. Same as calling `routeTraffic`.\n   *\n   * @default - the function's current revision (`currentRevision`)\n   */\n  readonly revision?: IWebFunctionRevision;\n\n  /**\n   * A second revision and its share of the endpoint's traffic; `revision` gets the rest.\n   * An endpoint routes to at most two revisions.\n   *\n   * @default - all traffic goes to `revision`\n   */\n  readonly additionalRevisions?: WebFunctionRevisionWeight[];\n}\n\n/**\n * Internal: how `WebFunction` creates its endpoints. Not part of the public API.\n */\ninterface WebFunctionEndpointProps extends AddWebFunctionEndpointOptions {\n  /** The function that owns the endpoint. */\n  readonly webFunction: IWebFunction;\n\n  /** The function's current revision, served unless `revision` is given. */\n  readonly currentRevision: IWebFunctionRevision;\n\n  /** Prefix of the generated endpoint name. */\n  readonly namePrefix: string;\n\n  /** Extra input to the generated name's hash (the construct ID of an added endpoint). */\n  readonly nameSeed?: string;\n}\n\n/**\n * An HTTPS endpoint of a Web Function: `fn.endpoint` (the default one) or the result of `fn.addEndpoint()`.\n *\n * Endpoints are created only through `WebFunction`, which owns their log groups in every region, so the constructor is private.\n */\nexport class WebFunctionEndpoint extends Construct {\n  /**\n   * Creates an endpoint of a Web Function. Used by `WebFunction`.\n   *\n   * @internal\n   */\n  public static _create(scope: Construct, id: string, props: WebFunctionEndpointProps): WebFunctionEndpoint {\n    return new WebFunctionEndpoint(scope, id, props);\n  }\n\n  /** The endpoint's name. */\n  public readonly endpointName: string;\n\n  /** The endpoint's ARN. */\n  public readonly endpointArn: string;\n\n  /** Where the endpoint serves traffic from. */\n  public readonly endpointType: WebFunctionEndpointType;\n\n  /** How callers of the endpoint are authenticated. */\n  public readonly authType: WebFunctionAuthType;\n\n  /** Every region the endpoint serves from: the home region first, then the others in alphabetical order. */\n  public readonly regions: string[];\n\n  /**\n   * The endpoint's domain name: the global domain for `MULTI_REGION`, otherwise the home region's.\n   */\n  public readonly domainName: string;\n\n  /**\n   * The endpoint's URL: the global URL for `MULTI_REGION`, otherwise the home region's.\n   */\n  public readonly url: string;\n\n  /** Grants on this endpoint (e.g. `grants.invoke(principal)`). */\n  public readonly grants: WebFunctionGrants;\n\n  /**\n   * The alarms this endpoint created for its deployment's `rollbackOn`, one per threshold in every region it serves from\n   * (the home region's first). Empty without `rollbackOn`.\n   */\n  public readonly rollbackAlarms: cloudwatch.IAlarm[] = [];\n\n  private readonly homeRegion: string;\n  private readonly webFunction: IWebFunction;\n  private readonly resource: lambda.CfnWebFunctionEndpoint;\n  private weights: lambda.CfnWebFunctionEndpoint.RevisionWeightProperty[];\n  private routed = false;\n  private readonly gradual: boolean;\n  private lookup?: EndpointLookup;\n\n  private constructor(scope: Construct, id: string, props: WebFunctionEndpointProps) {\n    super(scope, id);\n\n    const homeRegion = Stack.of(this).region;\n    const endpointType = props.endpointType ?? WebFunctionEndpointType.HOME_REGION;\n    const extraRegions = normaliseRegions(this, endpointType, homeRegion, props.regions ?? []);\n    validateRateLimit(this, props.rateLimit);\n    validateMaxEnvironments(this, props.maxEnvironments);\n\n    if (props.endpointName !== undefined) {\n      assertResourceName(this, 'endpointName', props.endpointName);\n      Annotations.of(this).addWarningV2('@cdk-lambda-web:explicitEndpointName',\n        `endpointName '${props.endpointName}' is set explicitly: changing endpointType or regions later also requires a new endpointName, otherwise the deployment fails with \"already exists\" (the stack rolls back safely). Omit endpointName to get a name that changes automatically.`);\n    }\n    if (props.authType === WebFunctionAuthType.NONE) {\n      Annotations.of(this).addWarningV2('@cdk-lambda-web:authTypeNone',\n        'authType NONE makes the endpoint public: Lambda does no authentication, so your application must authenticate requests itself.');\n    }\n\n    this.endpointType = endpointType;\n    this.authType = props.authType;\n    this.endpointName = props.endpointName ?? defaultEndpointName(props.namePrefix, props.nameSeed, endpointType, extraRegions);\n    this.regions = [homeRegion, ...extraRegions];\n    this.homeRegion = homeRegion;\n    this.webFunction = props.webFunction;\n    this.weights = [{ revisionId: props.currentRevision.revisionId, weight: 100 }];\n\n    const resource = new lambda.CfnWebFunctionEndpoint(this, 'Resource', {\n      functionName: props.webFunction.webFunctionArn,\n      endpointName: this.endpointName,\n      endpointType,\n      authType: props.authType,\n      description: props.description,\n      regions: extraRegions.length > 0 ? extraRegions : undefined,\n      revisionWeights: this.weights,\n      throttleConfig: props.rateLimit !== undefined ? { rateLimit: props.rateLimit } : undefined,\n      scalingConfig: props.maxEnvironments !== undefined ? { maxEnvironments: props.maxEnvironments } : undefined,\n    });\n    Validations.of(resource).acknowledge(CFN_VALIDATE_UNKNOWN_TYPE);\n    this.resource = resource;\n\n    this.gradual = props.deployment?._gradual ?? false;\n    if (props.deployment?._gradual) {\n      if (props.revision !== undefined || props.additionalRevisions !== undefined) {\n        throw new Error(`${this.node.path}: an endpoint with a ${props.deployment._kind} deployment always moves to the current revision; it can't also set revision or additionalRevisions`);\n      }\n      const rollbackAlarmArns = props.deployment._rollbackOn ? this.createRollbackAlarms(props.deployment._rollbackOn) : [];\n      const waitSeconds = props.deployment._waitSeconds;\n      const rollback = props.deployment._rollbackOn;\n      if (rollback && waitSeconds < rollback.period.toSeconds() * rollback.evaluationPeriods + 120) {\n        Annotations.of(this).addWarningV2('@cdk-lambda-web:rollbackSlowerThanStep',\n          `rollbackOn needs ${rollback.evaluationPeriods} period(s) of ${rollback.period.toHumanString()} plus about 2 minutes of CloudWatch delay to fire, longer than each ${props.deployment._kind} step (${Duration.seconds(waitSeconds).toHumanString()}): a bad revision can reach the next step before its alarm fires.`);\n      }\n      // Moves the traffic in steps before CloudFormation writes the endpoint, which then finds it already done.\n      const shift = new TrafficShift(this, 'Deployment', {\n        functionName: props.webFunction.webFunctionName,\n        functionArn: props.webFunction.webFunctionArn,\n        endpointName: this.endpointName,\n        revisionId: props.currentRevision.revisionId,\n        deployment: props.deployment,\n        alarmArns: rollbackAlarmArns,\n        endpointConfig: {\n          endpointType,\n          authType: props.authType,\n          description: props.description,\n          regions: extraRegions,\n          rateLimit: props.rateLimit,\n          maxEnvironments: props.maxEnvironments,\n        },\n      });\n      resource.node.addDependency(shift);\n      // Alarms in other regions are only referenced by ARN.\n      for (const alarm of this.node.findAll().filter((c) => c instanceof RegionalAlarm)) shift.node.addDependency(alarm);\n    }\n    if (props.revision !== undefined || props.additionalRevisions !== undefined) {\n      this.routeTraffic(props.revision ?? props.currentRevision, props.additionalRevisions);\n    }\n\n    this.endpointArn = resource.attrEndpointArn;\n    this.domainName = resource.attrDomainName;\n    this.url = `https://${resource.attrDomainName}`;\n    this.grants = WebFunctionGrants._forEndpoint(this);\n  }\n\n  /**\n   * The URL of this endpoint in one region. Only for `PER_REGION` endpoints.\n   *\n   * @param region one of `regions`\n   */\n  public regionalUrl(region: string): string {\n    if (this.endpointType !== WebFunctionEndpointType.PER_REGION) {\n      throw new Error(`${this.node.path}: regionalUrl() is only available for PER_REGION endpoints (this one is ${this.endpointType}); use url`);\n    }\n    if (!this.regions.includes(region)) {\n      throw new Error(`${this.node.path}: region ${region} is not one of the endpoint's regions (${this.regions.join(', ')})`);\n    }\n    if (region === this.homeRegion) {\n      return this.url;\n    }\n    this.lookup ??= new EndpointLookup(this, 'Lookup', {\n      functionName: this.webFunction.webFunctionName,\n      functionArn: this.webFunction.webFunctionArn,\n      endpointName: this.endpointName,\n      endpointArn: this.endpointArn,\n    });\n    return `https://${this.lookup.regionalDomain(region)}`;\n  }\n\n  /**\n   * Routes the endpoint to `revision` instead of the function's current revision, optionally sharing\n   * traffic with one more revision (`additionalRevisions`, which gets its weight; `revision` gets the rest).\n   *\n   * Use it to keep an endpoint on an earlier revision (`WebFunctionRevision.fromRevisionAttributes`),\n   * or to send part of the traffic to the current revision:\n   * `fn.endpoint.routeTraffic(previous, [{ revision: fn.currentRevision, weight: 0.1 }])`.\n   * Can be called once per endpoint, and not on one created with `revision` or `additionalRevisions`.\n   */\n  public routeTraffic(revision: IWebFunctionRevision, additionalRevisions?: WebFunctionRevisionWeight[]): void {\n    if (this.gradual) {\n      throw new Error(`${this.node.path}: the endpoint has a deployment in steps, which always moves it to the current revision; routeTraffic() can't be used with it`);\n    }\n    if (this.routed) {\n      throw new Error(`${this.node.path}: the endpoint's revisions are already set (revision, additionalRevisions or routeTraffic)`);\n    }\n    this.weights = revisionWeights(this, this.webFunction, revision, additionalRevisions ?? []);\n    this.resource.revisionWeights = this.weights;\n    this.routed = true;\n  }\n\n  /**\n   * The IDs of the revisions this endpoint routes to.\n   *\n   * @internal\n   */\n  public _revisionIds(): string[] {\n    return this.weights.map((w) => w.revisionId);\n  }\n\n  /**\n   * A metric of this endpoint in `AWS/Lambda/Web` (dimensions `FunctionName` and `EndpointName`).\n   *\n   * Metrics are published in the region that served the request: pass `region` for one of the endpoint's\n   * other regions. An alarm can only use metrics from its own stack's region.\n   *\n   * @default - sum over 1 minute, in the home region\n   */\n  public metric(metricName: string, props?: cloudwatch.MetricOptions): cloudwatch.Metric {\n    return new cloudwatch.Metric({\n      namespace: WEB_NAMESPACE,\n      metricName,\n      dimensionsMap: endpointDimensions(this.metricIds()),\n      statistic: cloudwatch.Stats.SUM,\n      period: DEFAULT_PERIOD,\n      ...props,\n    });\n  }\n\n  /** Requests the endpoint served (`ExecutedRequests`). There's no separate count of successful (2XX) responses. */\n  public metricRequests(props?: cloudwatch.MetricOptions): cloudwatch.Metric {\n    return this.metric(REQUESTS, props);\n  }\n\n  /**\n   * Requests answered with a 4XX status (`HTTPResponseStatusClass4XX`), including 429s from `rateLimit` and `maxEnvironments`.\n   * The metric only exists once it's non-zero, so alarms should treat missing data as not breaching.\n   */\n  public metricClientErrors(props?: cloudwatch.MetricOptions): cloudwatch.Metric {\n    return this.metric(CLIENT_ERRORS, props);\n  }\n\n  /**\n   * Requests answered with a 5XX status (`HTTPResponseStatusClass5XX`). Includes the platform's 503s while the endpoint\n   * scales up for a sudden burst, not only your application's errors. The metric only exists once it's non-zero.\n   */\n  public metricServerErrors(props?: cloudwatch.MetricOptions): cloudwatch.Metric {\n    return this.metric(SERVER_ERRORS, props);\n  }\n\n  /** The percentage of requests answered with a 4XX status (math expression; periods with no 4XX count as 0). */\n  public metricClientErrorRate(props?: cloudwatch.MetricOptions): cloudwatch.MathExpression {\n    return this.rate(CLIENT_ERRORS, 'Client error rate (%)', props);\n  }\n\n  /** The percentage of requests answered with a 5XX status (math expression; periods with no 5XX count as 0). */\n  public metricServerErrorRate(props?: cloudwatch.MetricOptions): cloudwatch.MathExpression {\n    return this.rate(SERVER_ERRORS, 'Server error rate (%)', props);\n  }\n\n  /**\n   * Execution environments serving the endpoint (`EndpointActiveEnvironments`), to compare with `maxEnvironments`.\n   *\n   * @default - maximum over 1 minute, in the home region\n   */\n  public metricActiveEnvironments(props?: cloudwatch.MetricOptions): cloudwatch.Metric {\n    return this.usageMetric('EndpointActiveEnvironments', cloudwatch.Stats.MAXIMUM, props);\n  }\n\n  /** Requests rejected with 429 because the endpoint reached its `rateLimit` (`EndpointRequestThrottles`). */\n  public metricRequestThrottles(props?: cloudwatch.MetricOptions): cloudwatch.Metric {\n    return this.usageMetric('EndpointRequestThrottles', cloudwatch.Stats.SUM, props);\n  }\n\n  /** Requests rejected with 429 because the endpoint reached `maxEnvironments` (`EndpointActiveEnvironmentThrottles`). */\n  public metricEnvironmentThrottles(props?: cloudwatch.MetricOptions): cloudwatch.Metric {\n    return this.usageMetric('EndpointActiveEnvironmentThrottles', cloudwatch.Stats.SUM, props);\n  }\n\n  /**\n   * Allows `grantee` to call this endpoint. Shortcut for `grants.invoke(grantee)`.\n   * [disable-awslint:no-grants]\n   */\n  public grantInvoke(grantee: iam.IGrantable): iam.Grant {\n    return this.grants.invoke(grantee);\n  }\n\n  private metricIds() {\n    return { functionName: this.webFunction.webFunctionName, endpointName: this.endpointName };\n  }\n\n  private rate(errorMetric: string, label: string, props?: cloudwatch.MetricOptions): cloudwatch.MathExpression {\n    const period = props?.period ?? DEFAULT_PERIOD;\n    const options = { period, region: props?.region, account: props?.account };\n    return new cloudwatch.MathExpression({\n      expression: rateExpression(1),\n      usingMetrics: { requests: this.metric(REQUESTS, options), errors: this.metric(errorMetric, options) },\n      period,\n      label: props?.label ?? label,\n    });\n  }\n\n  private usageMetric(metricName: string, statistic: string, props?: cloudwatch.MetricOptions): cloudwatch.Metric {\n    return new cloudwatch.Metric({\n      namespace: USAGE_NAMESPACE,\n      metricName,\n      dimensionsMap: { ...endpointDimensions(this.metricIds()), ExecutionRegion: props?.region ?? this.homeRegion },\n      statistic,\n      period: DEFAULT_PERIOD,\n      ...props,\n    });\n  }\n\n  /** One alarm per threshold in every serving region: a CloudFormation alarm at home, a custom resource elsewhere. Returns their ARNs. */\n  private createRollbackAlarms(rollback: ResolvedRollbackOptions): string[] {\n    const thresholds = [\n      { key: 'ServerErrors', short: '5xx', metric: SERVER_ERRORS, status: '5XX', threshold: rollback.serverErrorRate },\n      { key: 'ClientErrors', short: '4xx', metric: CLIENT_ERRORS, status: '4XX', threshold: rollback.clientErrorRate },\n    ];\n    const arns: string[] = [];\n    for (const t of thresholds) {\n      if (t.threshold === undefined) continue;\n      for (const region of this.regions) {\n        const description = `Rolls back deployments of endpoint ${this.endpointName} of ${this.webFunction.webFunctionName} when more than `\n          + `${t.threshold}% of its requests in ${region} get a ${t.status} response (${rollback.evaluationPeriods} x ${rollback.period.toHumanString()}, `\n          + `periods with fewer than ${rollback.minimumRequests} requests ignored).`;\n        if (region === this.homeRegion) {\n          const alarm = new cloudwatch.Alarm(this, `Rollback${t.key}`, {\n            metric: new cloudwatch.MathExpression({\n              expression: rateExpression(rollback.minimumRequests),\n              usingMetrics: {\n                requests: this.metric(REQUESTS, { period: rollback.period }),\n                errors: this.metric(t.metric, { period: rollback.period }),\n              },\n              period: rollback.period,\n              label: `${t.status} rate (%)`,\n            }),\n            threshold: t.threshold,\n            evaluationPeriods: rollback.evaluationPeriods,\n            comparisonOperator: cloudwatch.ComparisonOperator.GREATER_THAN_THRESHOLD,\n            treatMissingData: cloudwatch.TreatMissingData.NOT_BREACHING,\n            alarmDescription: description,\n          });\n          this.rollbackAlarms.push(alarm);\n          arns.push(alarm.alarmArn);\n        } else {\n          const alarm = new RegionalAlarm(this, `Rollback${t.key}-${region}`, {\n            region,\n            alarmName: `${ALARM_NAME_PREFIX}${this.webFunction.webFunctionName}-${this.endpointName}-${t.short}-rate`,\n            alarmDescription: description,\n            metrics: rateAlarmQueries(this.metricIds(), t.metric, rollback.period, rollback.minimumRequests),\n            threshold: t.threshold,\n            evaluationPeriods: rollback.evaluationPeriods,\n            comparisonOperator: cloudwatch.ComparisonOperator.GREATER_THAN_THRESHOLD,\n            treatMissingData: cloudwatch.TreatMissingData.NOT_BREACHING,\n          });\n          this.rollbackAlarms.push(cloudwatch.Alarm.fromAlarmArn(this, `Rollback${t.key}-${region}-Ref`, alarm.alarmArn));\n          arns.push(alarm.alarmArn);\n        }\n      }\n    }\n    return arns;\n  }\n}\n\nfunction normaliseRegions(scope: Construct, endpointType: WebFunctionEndpointType, homeRegion: string, regions: string[]): string[] {\n  const extra = [...new Set(regions)].filter((r) => r !== homeRegion).sort();\n  for (const r of regions) {\n    if (Token.isUnresolved(r)) {\n      throw new Error(`${scope.node.path}: regions must be literal region names, got a token`);\n    }\n    if (!/^[a-z]{2}(-[a-z]+)+-\\d$/.test(r)) {\n      throw new Error(`${scope.node.path}: '${r}' is not a valid region name`);\n    }\n  }\n  if (endpointType === WebFunctionEndpointType.HOME_REGION && extra.length > 0) {\n    throw new Error(`${scope.node.path}: a HOME_REGION endpoint serves only the home region (${homeRegion}); use MULTI_REGION or PER_REGION to add ${extra.join(', ')}`);\n  }\n  if (endpointType !== WebFunctionEndpointType.HOME_REGION) {\n    if (Token.isUnresolved(homeRegion)) {\n      throw new Error(`${scope.node.path}: ${endpointType} endpoints need a stack with an explicit region (env.region)`);\n    }\n    if (extra.length === 0) {\n      throw new Error(`${scope.node.path}: a ${endpointType} endpoint needs at least one region besides the home region (${homeRegion})`);\n    }\n  }\n  return extra;\n}\n\nfunction validateRateLimit(scope: Construct, rateLimit: number | undefined): void {\n  if (rateLimit === undefined || Token.isUnresolved(rateLimit)) return;\n  const allowed = rateLimit === 0\n    || (rateLimit >= 100 && rateLimit <= 1000 && rateLimit % 100 === 0)\n    || (rateLimit >= 2000 && rateLimit <= 10000 && rateLimit % 1000 === 0);\n  if (!allowed) {\n    throw new Error(`${scope.node.path}: rateLimit must be 0, 100-1,000 in steps of 100, or 2,000-10,000 in steps of 1,000, got ${rateLimit}`);\n  }\n}\n\nfunction validateMaxEnvironments(scope: Construct, maxEnvironments: number | undefined): void {\n  if (maxEnvironments === undefined || Token.isUnresolved(maxEnvironments)) return;\n  if (!Number.isInteger(maxEnvironments) || maxEnvironments < 2 || maxEnvironments > 10000) {\n    throw new Error(`${scope.node.path}: maxEnvironments must be an integer from 2 to 10,000, got ${maxEnvironments}`);\n  }\n}\n\n/** `primary` gets what `additional` leaves; weights are whole percentages summing to 100. */\nfunction revisionWeights(\n  scope: Construct,\n  webFunction: IWebFunction,\n  primary: IWebFunctionRevision,\n  additional: WebFunctionRevisionWeight[],\n): lambda.CfnWebFunctionEndpoint.RevisionWeightProperty[] {\n  for (const r of [primary, ...additional.map((a) => a.revision)]) {\n    if (r.webFunction !== webFunction) {\n      throw new Error(`${scope.node.path}: revision ${r.revisionId} belongs to another function`);\n    }\n  }\n  if (additional.length === 0) {\n    return [{ revisionId: primary.revisionId, weight: 100 }];\n  }\n  if (additional.length > 1) {\n    throw new Error(`${scope.node.path}: an endpoint routes to at most two revisions, so additionalRevisions takes one`);\n  }\n  const [{ revision, weight }] = additional;\n  const percent = Math.round(weight * 100);\n  if (Token.isUnresolved(weight) || Math.abs(weight * 100 - percent) > 1e-9 || percent < 1 || percent > 99) {\n    throw new Error(`${scope.node.path}: an additional revision's weight must be a whole percentage from 0.01 to 0.99, got ${weight}`);\n  }\n  if (revision === primary || (!Token.isUnresolved(revision.revisionId) && revision.revisionId === primary.revisionId)) {\n    throw new Error(`${scope.node.path}: the additional revision is the same as the endpoint's revision`);\n  }\n  return [{ revisionId: primary.revisionId, weight: 100 - percent }, { revisionId: revision.revisionId, weight: percent }];\n}\n\n/**\n * `<prefix>-<hash>`, with the hash covering the endpoint type and regions: a type or region change produces\n * a new name, so the replacement doesn't collide with the endpoint it replaces.\n */\nfunction defaultEndpointName(prefix: string, seed: string | undefined, endpointType: WebFunctionEndpointType, extraRegions: string[]): string {\n  const hash = createHash('sha256').update([...(seed !== undefined ? [seed] : []), endpointType, ...extraRegions].join(',')).digest('hex').slice(0, 8);\n  return `${prefix}-${hash}`;\n}\n"]}

package/lib/web-function-grants.d.ts

@@ -1,7 +1,7 @@
 import * as iam from 'aws-cdk-lib/aws-iam';
 import type { WebFunctionEndpoint } from './web-function-endpoint';
 /**
- * Grants on a Web Function. Access it as `fn.grants`.
+ * Grants on a Web Function endpoint. Access them as `fn.grants` (the default endpoint) or `endpoint.grants`.
  */
 export declare class WebFunctionGrants {
     private readonly endpoint;
@@ -11,7 +11,7 @@ export declare class WebFunctionGrants {
     static _forEndpoint(endpoint: WebFunctionEndpoint): WebFunctionGrants;
     private constructor();
     /**
-     * Allows `grantee` to call the function's endpoint (`lambda:InvokeWebFunctionEndpoint`).
+     * Allows `grantee` to call the endpoint (`lambda:InvokeWebFunctionEndpoint`).
      *
      * The grant is on the endpoint's home-region ARN, which IAM evaluates for every region the
      * endpoint serves from, including a MULTI_REGION global URL.

package/lib/web-function-grants.js

@@ -37,11 +37,11 @@ exports.WebFunctionGrants = void 0;
 const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
 const iam = __importStar(require("aws-cdk-lib/aws-iam"));
 /**
- * Grants on a Web Function. Access it as `fn.grants`.
+ * Grants on a Web Function endpoint. Access them as `fn.grants` (the default endpoint) or `endpoint.grants`.
  */
 class WebFunctionGrants {
     endpoint;
-    static [JSII_RTTI_SYMBOL_1] = { fqn: "@ashishpandeyone/cdk-lambda-web-function.WebFunctionGrants", version: "0.1.1" };
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "@ashishpandeyone/cdk-lambda-web-function.WebFunctionGrants", version: "0.1.3" };
     /**
      * @internal
      */
@@ -52,7 +52,7 @@ class WebFunctionGrants {
         this.endpoint = endpoint;
     }
     /**
-     * Allows `grantee` to call the function's endpoint (`lambda:InvokeWebFunctionEndpoint`).
+     * Allows `grantee` to call the endpoint (`lambda:InvokeWebFunctionEndpoint`).
      *
      * The grant is on the endpoint's home-region ARN, which IAM evaluates for every region the
      * endpoint serves from, including a MULTI_REGION global URL.
@@ -66,4 +66,4 @@ class WebFunctionGrants {
     }
 }
 exports.WebFunctionGrants = WebFunctionGrants;
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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