@ashishpandeyone/cdk-lambda-web-function 0.1.0 → 0.1.2

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

@@ -1,5 +1,22 @@
+import * as iam from 'aws-cdk-lib/aws-iam';
 import { Construct } from 'constructs';
 import { WebFunctionAuthType, WebFunctionEndpointType } from './enums';
+import type { IWebFunction } from './web-function';
+import type { WebFunctionDeployment } from './web-function-deployment';
+import { WebFunctionGrants } from './web-function-grants';
+import type { IWebFunctionRevision } from './web-function-revision';
+/**
+ * A revision and the share of an endpoint's traffic it receives.
+ */
+export interface WebFunctionRevisionWeight {
+    /** The revision. */
+    readonly revision: IWebFunctionRevision;
+    /**
+     * The revision's share of the endpoint's traffic, as a fraction (like `lambda.Alias` `additionalVersions`).
+     * Must be a whole percentage from 0.01 to 0.99.
+     */
+    readonly weight: number;
+}
 /**
  * Options for a Web Function's endpoint.
  */
@@ -21,37 +38,95 @@ export interface WebFunctionEndpointOptions {
     readonly regions?: string[];
     /**
      * The endpoint's name, shown in logs (`endpointName`) and in the `lambda-web-endpoint-name` header.
+     * Names are unique per function.
      *
-     * When omitted, the name is `default-<hash>`, with the hash covering the endpoint type and regions,
-     * so changing either deploys a new endpoint cleanly. When set, changing the endpoint type or
-     * regions also requires a new name: two endpoints of one function can't share a name, and
-     * CloudFormation creates the replacement before deleting the old one.
+     * When omitted, the name ends in a hash of the endpoint type and regions, so changing either deploys
+     * a new endpoint cleanly. When set, changing the endpoint type or regions also requires a new name:
+     * two endpoints of one function can't share a name, and CloudFormation creates the replacement
+     * before deleting the old one.
      *
-     * @default - `default-<hash of type and regions>`
+     * @default - `default-<hash>` for the function's default endpoint, `<id>-<hash>` for endpoints added with `addEndpoint`
      */
     readonly endpointName?: string;
+    /**
+     * A description of the endpoint.
+     *
+     * @default - no description
+     */
+    readonly description?: string;
+    /**
+     * The most requests per second the endpoint accepts; excess requests get HTTP 429.
+     * Allowed: 0 (blocks all traffic), 100–1,000 in steps of 100, or 2,000–10,000 in steps of 1,000.
+     *
+     * Enforced separately in each region the endpoint serves from, so a multi-region endpoint
+     * can accept this many requests per second in every region.
+     *
+     * @default - no limit beyond the service quota of 10,000 requests per second per endpoint (per region)
+     */
+    readonly rateLimit?: number;
+    /**
+     * The most execution environments the endpoint may use (2–10,000). Each one uses 2 vCPUs of the account's quota.
+     *
+     * Enforced separately in each region the endpoint serves from.
+     *
+     * @default - scales within the account's vCPU quota
+     */
+    readonly maxEnvironments?: number;
+    /**
+     * How the endpoint moves its traffic to a new revision: all at once, or in steps
+     * (`WebFunctionDeployment.canary()` or `linear()`) that watch CloudWatch alarms and move
+     * the traffic back when one goes into ALARM.
+     *
+     * A deployment in steps can't be combined with `revision`, `additionalRevisions` or `routeTraffic()`.
+     *
+     * @default WebFunctionDeployment.allAtOnce()
+     */
+    readonly deployment?: WebFunctionDeployment;
 }
 /**
- * Internal: how `WebFunction` creates its endpoint. Not part of the public API.
+ * Options for `WebFunction.addEndpoint`.
  */
-interface WebFunctionEndpointProps extends WebFunctionEndpointOptions {
-    /** Literal name of the Web Function (the provider's IAM must not reference resource attributes). */
-    readonly functionName: string;
-    /** The Web Function's ARN. */
-    readonly functionArn: string;
-    /** ID of the revision the endpoint serves. */
-    readonly revisionId: string;
-    /** How callers are authenticated. */
+export interface AddWebFunctionEndpointOptions extends WebFunctionEndpointOptions {
+    /**
+     * How callers of this endpoint are authenticated.
+     */
     readonly authType: WebFunctionAuthType;
+    /**
+     * The revision the endpoint serves, e.g. an earlier one from `WebFunctionRevision.fromRevisionAttributes`
+     * to keep this endpoint on it while others move on. Same as calling `routeTraffic`.
+     *
+     * @default - the function's current revision (`currentRevision`)
+     */
+    readonly revision?: IWebFunctionRevision;
+    /**
+     * A second revision and its share of the endpoint's traffic; `revision` gets the rest.
+     * An endpoint routes to at most two revisions.
+     *
+     * @default - all traffic goes to `revision`
+     */
+    readonly additionalRevisions?: WebFunctionRevisionWeight[];
+}
+/**
+ * Internal: how `WebFunction` creates its endpoints. Not part of the public API.
+ */
+interface WebFunctionEndpointProps extends AddWebFunctionEndpointOptions {
+    /** The function that owns the endpoint. */
+    readonly webFunction: IWebFunction;
+    /** The function's current revision, served unless `revision` is given. */
+    readonly currentRevision: IWebFunctionRevision;
+    /** Prefix of the generated endpoint name. */
+    readonly namePrefix: string;
+    /** Extra input to the generated name's hash (the construct ID of an added endpoint). */
+    readonly nameSeed?: string;
 }
 /**
- * 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.
  */
 export declare class WebFunctionEndpoint extends Construct {
     /**
-     * Creates the endpoint of a Web Function. Used by `WebFunction`.
+     * Creates an endpoint of a Web Function. Used by `WebFunction`.
      *
      * @internal
      */
@@ -62,6 +137,8 @@ export declare class WebFunctionEndpoint extends Construct {
     readonly endpointArn: string;
     /** Where the endpoint serves traffic from. */
     readonly endpointType: WebFunctionEndpointType;
+    /** How callers of the endpoint are authenticated. */
+    readonly authType: WebFunctionAuthType;
     /** Every region the endpoint serves from: the home region first, then the others in alphabetical order. */
     readonly regions: string[];
     /**
@@ -72,9 +149,14 @@ export declare class WebFunctionEndpoint extends Construct {
      * The endpoint's URL: the global URL for `MULTI_REGION`, otherwise the home region's.
      */
     readonly url: string;
+    /** Grants on this endpoint (e.g. `grants.invoke(principal)`). */
+    readonly grants: WebFunctionGrants;
     private readonly homeRegion;
-    private readonly functionName;
-    private readonly functionArn;
+    private readonly webFunction;
+    private readonly resource;
+    private weights;
+    private routed;
+    private readonly gradual;
     private lookup?;
     private constructor();
     /**
@@ -83,5 +165,26 @@ export declare class WebFunctionEndpoint extends Construct {
      * @param region one of `regions`
      */
     regionalUrl(region: string): string;
+    /**
+     * 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: IWebFunctionRevision, additionalRevisions?: WebFunctionRevisionWeight[]): void;
+    /**
+     * The IDs of the revisions this endpoint routes to.
+     *
+     * @internal
+     */
+    _revisionIds(): string[];
+    /**
+     * Allows `grantee` to call this endpoint. Shortcut for `grants.invoke(grantee)`.
+     * [disable-awslint:no-grants]
+     */
+    grantInvoke(grantee: iam.IGrantable): iam.Grant;
 }
 export {};

package/lib/web-function-endpoint.js

@@ -41,16 +41,18 @@ 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 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.0" };
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "@ashishpandeyone/cdk-lambda-web-function.WebFunctionEndpoint", version: "0.1.2" };
     /**
-     * Creates the endpoint of a Web Function. Used by `WebFunction`.
+     * Creates an endpoint of a Web Function. Used by `WebFunction`.
      *
      * @internal
      */
@@ -63,6 +65,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 +77,22 @@ 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;
     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 +101,55 @@ 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`);
+            }
+            // 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,
+                endpointConfig: {
+                    endpointType,
+                    authType: props.authType,
+                    description: props.description,
+                    regions: extraRegions,
+                    rateLimit: props.rateLimit,
+                    maxEnvironments: props.maxEnvironments,
+                },
+            });
+            resource.node.addDependency(shift);
+        }
+        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 +167,48 @@ 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);
+    }
+    /**
+     * Allows `grantee` to call this endpoint. Shortcut for `grants.invoke(grantee)`.
+     * [disable-awslint:no-grants]
+     */
+    grantInvoke(grantee) {
+        return this.grants.invoke(grantee);
+    }
 }
 exports.WebFunctionEndpoint = WebFunctionEndpoint;
 function normaliseRegions(scope, endpointType, homeRegion, regions) {
@@ -156,9 +234,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, Stack, Token, Validations } from 'aws-cdk-lib';\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 { 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  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      // 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        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    }\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   * 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\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.0" };
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "@ashishpandeyone/cdk-lambda-web-function.WebFunctionGrants", version: "0.1.2" };
     /**
      * @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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

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

@@ -0,0 +1,45 @@
+import type * as lambda from 'aws-cdk-lib/aws-lambda';
+import { Construct, type IConstruct } from 'constructs';
+/**
+ * A revision of a Web Function: an immutable snapshot of its code and configuration.
+ */
+export interface IWebFunctionRevision extends IConstruct {
+    /** The revision's ID, e.g. `rev-a1b2c`. */
+    readonly revisionId: string;
+    /** The revision's ARN. */
+    readonly revisionArn: string;
+    /** The function the revision belongs to. */
+    readonly webFunction: lambda.IWebFunctionRef;
+}
+/**
+ * Attributes of an existing revision.
+ */
+export interface WebFunctionRevisionAttributes {
+    /** The function the revision belongs to. */
+    readonly webFunction: lambda.IWebFunctionRef;
+    /** The revision's ID, e.g. `rev-a1b2c` (the `revisionId` of an earlier deployment). */
+    readonly revisionId: string;
+}
+/**
+ * A revision of a Web Function.
+ *
+ * `WebFunction` creates its current revision (`fn.currentRevision`) from its code and configuration.
+ * Use `fromRevisionAttributes` to route an endpoint to an earlier one, which must still exist:
+ * only revisions within `revisionRetention`, or that an endpoint routes to, are kept.
+ */
+export declare class WebFunctionRevision extends Construct implements IWebFunctionRevision {
+    /**
+     * References an existing revision of `webFunction`, e.g. to pin an endpoint to it or split traffic with it.
+     */
+    static fromRevisionAttributes(scope: Construct, id: string, attrs: WebFunctionRevisionAttributes): IWebFunctionRevision;
+    /**
+     * The revision `WebFunction` creates.
+     *
+     * @internal
+     */
+    static _current(scope: Construct, id: string, webFunction: lambda.IWebFunctionRef, revisionId: string, revisionArn: string): WebFunctionRevision;
+    readonly webFunction: lambda.IWebFunctionRef;
+    readonly revisionId: string;
+    readonly revisionArn: string;
+    private constructor();
+}