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

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();
+}

package/lib/web-function-revision.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebFunctionRevision = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const constructs_1 = require("constructs");
+/**
+ * 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.
+ */
+class WebFunctionRevision extends constructs_1.Construct {
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "@ashishpandeyone/cdk-lambda-web-function.WebFunctionRevision", version: "0.1.3" };
+    /**
+     * References an existing revision of `webFunction`, e.g. to pin an endpoint to it or split traffic with it.
+     */
+    static fromRevisionAttributes(scope, id, attrs) {
+        return new WebFunctionRevision(scope, id, attrs.webFunction, attrs.revisionId, `${attrs.webFunction.webFunctionRef.functionArn}/revision/${attrs.revisionId}`);
+    }
+    /**
+     * The revision `WebFunction` creates.
+     *
+     * @internal
+     */
+    static _current(scope, id, webFunction, revisionId, revisionArn) {
+        return new WebFunctionRevision(scope, id, webFunction, revisionId, revisionArn);
+    }
+    webFunction;
+    revisionId;
+    revisionArn;
+    constructor(scope, id, webFunction, revisionId, revisionArn) {
+        super(scope, id);
+        this.webFunction = webFunction;
+        this.revisionId = revisionId;
+        this.revisionArn = revisionArn;
+    }
+}
+exports.WebFunctionRevision = WebFunctionRevision;
+//# sourceMappingURL=data:application/json;base64,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

package/lib/web-function.d.ts

@@ -1,11 +1,13 @@
 import { Duration, type IResource, RemovalPolicy, Resource } from 'aws-cdk-lib';
+import * as cloudwatch from 'aws-cdk-lib/aws-cloudwatch';
 import * as iam from 'aws-cdk-lib/aws-iam';
 import * as lambda from 'aws-cdk-lib/aws-lambda';
 import * as logs from 'aws-cdk-lib/aws-logs';
 import { Construct } from 'constructs';
 import { WebFunctionAuthType } from './enums';
-import { WebFunctionEndpoint, type WebFunctionEndpointOptions } from './web-function-endpoint';
+import { WebFunctionEndpoint, type AddWebFunctionEndpointOptions, type WebFunctionEndpointOptions } from './web-function-endpoint';
 import { WebFunctionGrants } from './web-function-grants';
+import { type IWebFunctionRevision } from './web-function-revision';
 /**
  * Options shared by `WebFunction` and `NodejsWebFunction`: everything except how the code is supplied.
  */
@@ -15,11 +17,24 @@ export interface WebFunctionOptions {
      */
     readonly authType: WebFunctionAuthType;
     /**
-     * The endpoint: where it serves from, and its name.
+     * The default endpoint (`fn.endpoint`): where it serves from, its name and limits.
+     * It serves the current revision; route it elsewhere with `fn.endpoint.routeTraffic()`.
+     * Add more endpoints with `addEndpoint`.
      *
-     * @default - a HOME_REGION endpoint
+     * @default - a HOME_REGION endpoint serving the current revision
      */
     readonly endpoint?: WebFunctionEndpointOptions;
+    /**
+     * How many of the newest revisions to keep (1-50). Each deployment that changes the code or
+     * configuration creates a revision; older ones stay available to roll back to or route traffic to,
+     * and the oldest beyond this count are deleted after each deployment.
+     *
+     * Revisions that an endpoint routes to are never deleted, and neither are those the previous
+     * deployment used (a rollback returns to them).
+     *
+     * @default 20
+     */
+    readonly revisionRetention?: number;
     /**
      * The function's name. Renaming a function replaces it, and its endpoint gets a new URL.
      *
@@ -130,8 +145,9 @@ export interface IWebFunction extends IResource, lambda.IWebFunctionRef {
 /**
  * A Node.js HTTP server running as an AWS Lambda Web Function, served from one or more regions.
  *
- * Creates the function, its current revision (code and configuration; any change replaces it),
- * an HTTPS endpoint, an execution role, and owns the function's log groups in every region.
+ * Creates the function, its current revision (code and configuration; any change creates a new one,
+ * and the newest `revisionRetention` are kept), a default HTTPS endpoint, an execution role, and owns
+ * the function's log groups in every region its endpoints serve from.
  *
  * Importing existing functions (`fromXxx` methods) is planned after 0.1.
  *
@@ -140,11 +156,13 @@ export interface IWebFunction extends IResource, lambda.IWebFunctionRef {
 export declare class WebFunction extends Resource implements IWebFunction, iam.IGrantable {
     readonly webFunctionName: string;
     readonly webFunctionArn: string;
-    /** The ID of the current revision. */
+    /** The ID of the current revision. Same as `currentRevision.revisionId`. */
     readonly revisionId: string;
-    /** The function's endpoint. */
+    /** The revision built from the current code and configuration. */
+    readonly currentRevision: IWebFunctionRevision;
+    /** The default endpoint. Add more with `addEndpoint`. */
     readonly endpoint: WebFunctionEndpoint;
-    /** Grants on the function (e.g. `grants.invoke(principal)`). */
+    /** Grants on the default endpoint (e.g. `grants.invoke(principal)`). Other endpoints have their own `grants`. */
     readonly grants: WebFunctionGrants;
     /** The execution role. */
     readonly role: iam.IRole;
@@ -156,9 +174,22 @@ export declare class WebFunction extends Resource implements IWebFunction, iam.I
      */
     readonly logGroup: logs.ILogGroup;
     private readonly environment;
+    private readonly endpoints;
+    private readonly remoteLogGroups;
+    private readonly logGroupName;
+    private readonly logOptions;
+    private readonly resource;
+    private readonly revisionCleanup;
     /** A reference to this function, for APIs that accept `lambda.IWebFunctionRef`. */
     get webFunctionRef(): lambda.WebFunctionReference;
     constructor(scope: Construct, id: string, props: WebFunctionProps);
+    /**
+     * Adds an endpoint (up to 10 per function), e.g. a public one next to an IAM-only one, or one pinned to an
+     * earlier revision. Each endpoint has its own URL, authentication, regions and limits.
+     *
+     * @param id the endpoint's construct ID, also used in its generated name (`<id>-<hash>`)
+     */
+    addEndpoint(id: string, options: AddWebFunctionEndpointOptions): WebFunctionEndpoint;
     /**
      * Adds an environment variable. Names starting with `AWS_` are reserved.
      */
@@ -172,7 +203,36 @@ export declare class WebFunction extends Resource implements IWebFunction, iam.I
      * [disable-awslint:no-grants]
      */
     grantInvoke(grantee: iam.IGrantable): iam.Grant;
+    /**
+     * A metric of this function's execution environments in `AWS/Lambda/Web` (dimension `FunctionName`), across all endpoints.
+     * For request and error counts, use the endpoint's metrics (`fn.endpoint.metricRequests()`).
+     *
+     * Metrics are published in the region that served the request: pass `region` for another serving region.
+     * An alarm can only use metrics from its own stack's region.
+     *
+     * @default - sum over 1 minute, in the home region
+     */
+    metric(metricName: string, props?: cloudwatch.MetricOptions): cloudwatch.Metric;
+    /** Time the execution environments were active (`EnvironmentActiveTime`). */
+    metricActiveTime(props?: cloudwatch.MetricOptions): cloudwatch.Metric;
+    /** CPU time the execution environments used (`EnvironmentCPUTime`). */
+    metricCpuTime(props?: cloudwatch.MetricOptions): cloudwatch.Metric;
+    /**
+     * Requests an execution environment handled at once (`EnvironmentConcurrentRequests`), to compare with
+     * `maxConcurrencyPerEnvironment`.
+     *
+     * @default - maximum over 1 minute
+     */
+    metricConcurrentRequests(props?: cloudwatch.MetricOptions): cloudwatch.Metric;
+    /**
+     * Peak memory an execution environment used (`EnvironmentMaxMemoryUsage`); each environment has 2 GB.
+     *
+     * @default - maximum over 1 minute
+     */
+    metricMaxMemoryUsage(props?: cloudwatch.MetricOptions): cloudwatch.Metric;
+    /** Bytes sent in responses (`ResponseBytes`). */
+    metricResponseBytes(props?: cloudwatch.MetricOptions): cloudwatch.Metric;
+    private createEndpoint;
     private createLogGroups;
-    private createRemoteLogGroups;
     private logGroupIn;
 }

package/lib/web-function.js

@@ -36,33 +36,41 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.WebFunction = void 0;
 const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
 const aws_cdk_lib_1 = require("aws-cdk-lib");
+const cloudwatch = __importStar(require("aws-cdk-lib/aws-cloudwatch"));
 const iam = __importStar(require("aws-cdk-lib/aws-iam"));
 const lambda = __importStar(require("aws-cdk-lib/aws-lambda"));
 const logs = __importStar(require("aws-cdk-lib/aws-logs"));
 const code_1 = require("./private/code");
 const log_group_1 = require("./private/log-group");
+const metrics_1 = require("./private/metrics");
+const revision_cleanup_1 = require("./private/revision-cleanup");
 const validation_1 = require("./private/validation");
 const web_function_endpoint_1 = require("./web-function-endpoint");
-const web_function_grants_1 = require("./web-function-grants");
+const web_function_revision_1 = require("./web-function-revision");
+/** Endpoints per function (service quota, not adjustable). */
+const MAX_ENDPOINTS = 10;
 /**
  * A Node.js HTTP server running as an AWS Lambda Web Function, served from one or more regions.
  *
- * Creates the function, its current revision (code and configuration; any change replaces it),
- * an HTTPS endpoint, an execution role, and owns the function's log groups in every region.
+ * Creates the function, its current revision (code and configuration; any change creates a new one,
+ * and the newest `revisionRetention` are kept), a default HTTPS endpoint, an execution role, and owns
+ * the function's log groups in every region its endpoints serve from.
  *
  * Importing existing functions (`fromXxx` methods) is planned after 0.1.
  *
  * @resource AWS::Lambda::WebFunction
  */
 class WebFunction extends aws_cdk_lib_1.Resource {
-    static [JSII_RTTI_SYMBOL_1] = { fqn: "@ashishpandeyone/cdk-lambda-web-function.WebFunction", version: "0.1.1" };
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "@ashishpandeyone/cdk-lambda-web-function.WebFunction", version: "0.1.3" };
     webFunctionName;
     webFunctionArn;
-    /** The ID of the current revision. */
+    /** The ID of the current revision. Same as `currentRevision.revisionId`. */
     revisionId;
-    /** The function's endpoint. */
+    /** The revision built from the current code and configuration. */
+    currentRevision;
+    /** The default endpoint. Add more with `addEndpoint`. */
     endpoint;
-    /** Grants on the function (e.g. `grants.invoke(principal)`). */
+    /** Grants on the default endpoint (e.g. `grants.invoke(principal)`). Other endpoints have their own `grants`. */
     grants;
     /** The execution role. */
     role;
@@ -74,6 +82,12 @@ class WebFunction extends aws_cdk_lib_1.Resource {
      */
     logGroup;
     environment = {};
+    endpoints = [];
+    remoteLogGroups = new Map();
+    logGroupName;
+    logOptions;
+    resource;
+    revisionCleanup;
     /** A reference to this function, for APIs that accept `lambda.IWebFunctionRef`. */
     get webFunctionRef() {
         return { functionArn: this.webFunctionArn };
@@ -92,6 +106,10 @@ class WebFunction extends aws_cdk_lib_1.Resource {
         if (maxConcurrency !== undefined && !aws_cdk_lib_1.Token.isUnresolved(maxConcurrency) && !validConcurrency(maxConcurrency)) {
             throw new Error(`${this.node.path}: maxConcurrencyPerEnvironment must be an integer from 1 to 128, got ${maxConcurrency}`);
         }
+        const revisionRetention = props.revisionRetention ?? 20;
+        if (!aws_cdk_lib_1.Token.isUnresolved(revisionRetention) && (!Number.isInteger(revisionRetention) || revisionRetention < 1 || revisionRetention > 50)) {
+            throw new Error(`${this.node.path}: revisionRetention must be an integer from 1 to 50, got ${revisionRetention}`);
+        }
         const systemLogLevels = [lambda.SystemLogLevel.DEBUG, lambda.SystemLogLevel.INFO, lambda.SystemLogLevel.WARN];
         if (props.systemLogLevelV2 !== undefined && !systemLogLevels.includes(props.systemLogLevelV2)) {
             throw new Error(`${this.node.path}: systemLogLevelV2 must be DEBUG, INFO or WARN for Lambda Web Functions`);
@@ -111,7 +129,9 @@ class WebFunction extends aws_cdk_lib_1.Resource {
         this.grantPrincipal = this.role;
         // Log groups first: the service would otherwise create them without retention.
         const logGroupName = `/aws/lambda/web/${this.webFunctionName}`;
-        const logGroups = this.createLogGroups(logGroupName, props);
+        this.logGroupName = logGroupName;
+        this.logOptions = { logRetention: props.logRetention, logRemovalPolicy: props.logRemovalPolicy };
+        const logGroups = this.createLogGroups(logGroupName);
         this.logGroup = logs.LogGroup.fromLogGroupName(this, 'LogGroup', logGroupName);
         const code = new code_1.WebFunctionCode(this, 'Code', props.code).location;
         const fn = new lambda.CfnWebFunction(this, 'Resource', { functionName: this.webFunctionName });
@@ -119,6 +139,7 @@ class WebFunction extends aws_cdk_lib_1.Resource {
         for (const group of logGroups)
             fn.node.addDependency(group.resource);
         aws_cdk_lib_1.Validations.of(fn).acknowledge(validation_1.CFN_VALIDATE_UNKNOWN_TYPE);
+        this.resource = fn;
         this.webFunctionArn = fn.attrFunctionArn;
         const revision = new lambda.CfnWebFunctionRevision(this, 'Revision', {
             functionName: fn.attrFunctionArn,
@@ -144,18 +165,28 @@ class WebFunction extends aws_cdk_lib_1.Resource {
         // Wait for the role's policies, so the first environment starts with its permissions.
         revision.node.addDependency(this.role);
         aws_cdk_lib_1.Validations.of(revision).acknowledge(validation_1.CFN_VALIDATE_UNKNOWN_TYPE);
+        // Replaced revisions stay as rollback targets; RevisionCleanup deletes the oldest. Deleting the function deletes them all.
+        revision.applyRemovalPolicy(aws_cdk_lib_1.RemovalPolicy.RETAIN);
         this.revisionId = revision.attrRevisionId;
-        this.endpoint = web_function_endpoint_1.WebFunctionEndpoint._create(this, 'Endpoint', {
-            ...props.endpoint,
+        this.currentRevision = web_function_revision_1.WebFunctionRevision._current(this, 'CurrentRevision', this, revision.attrRevisionId, revision.attrRevisionArn);
+        this.revisionCleanup = new revision_cleanup_1.RevisionCleanup(this, 'RevisionCleanup', {
             functionName: this.webFunctionName,
             functionArn: fn.attrFunctionArn,
-            revisionId: revision.attrRevisionId,
-            authType: props.authType,
+            keep: revisionRetention,
+            revisionIds: () => [this.currentRevision.revisionId, ...this.endpoints.flatMap((e) => e._revisionIds())],
         });
-        this.grants = web_function_grants_1.WebFunctionGrants._forEndpoint(this.endpoint);
-        // Remote regions' .local groups can only be created once the regions are known.
-        for (const group of this.createRemoteLogGroups(logGroupName, props))
-            fn.node.addDependency(group.resource);
+        this.endpoint = this.createEndpoint('Endpoint', { ...props.endpoint, authType: props.authType }, 'default');
+        this.grants = this.endpoint.grants;
+    }
+    /**
+     * Adds an endpoint (up to 10 per function), e.g. a public one next to an IAM-only one, or one pinned to an
+     * earlier revision. Each endpoint has its own URL, authentication, regions and limits.
+     *
+     * @param id the endpoint's construct ID, also used in its generated name (`<id>-<hash>`)
+     */
+    addEndpoint(id, options) {
+        const prefix = id.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-+/, '').slice(0, 55).replace(/-+$/, '') || 'endpoint';
+        return this.createEndpoint(id, options, prefix, id);
     }
     /**
      * Adds an environment variable. Names starting with `AWS_` are reserved.
@@ -180,24 +211,97 @@ class WebFunction extends aws_cdk_lib_1.Resource {
     grantInvoke(grantee) {
         return this.grants.invoke(grantee);
     }
-    createLogGroups(logGroupName, props) {
+    /**
+     * A metric of this function's execution environments in `AWS/Lambda/Web` (dimension `FunctionName`), across all endpoints.
+     * For request and error counts, use the endpoint's metrics (`fn.endpoint.metricRequests()`).
+     *
+     * Metrics are published in the region that served the request: pass `region` for another serving region.
+     * 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: { FunctionName: this.webFunctionName },
+            statistic: cloudwatch.Stats.SUM,
+            period: metrics_1.DEFAULT_PERIOD,
+            ...props,
+        });
+    }
+    /** Time the execution environments were active (`EnvironmentActiveTime`). */
+    metricActiveTime(props) {
+        return this.metric('EnvironmentActiveTime', props);
+    }
+    /** CPU time the execution environments used (`EnvironmentCPUTime`). */
+    metricCpuTime(props) {
+        return this.metric('EnvironmentCPUTime', props);
+    }
+    /**
+     * Requests an execution environment handled at once (`EnvironmentConcurrentRequests`), to compare with
+     * `maxConcurrencyPerEnvironment`.
+     *
+     * @default - maximum over 1 minute
+     */
+    metricConcurrentRequests(props) {
+        return this.metric('EnvironmentConcurrentRequests', { statistic: cloudwatch.Stats.MAXIMUM, ...props });
+    }
+    /**
+     * Peak memory an execution environment used (`EnvironmentMaxMemoryUsage`); each environment has 2 GB.
+     *
+     * @default - maximum over 1 minute
+     */
+    metricMaxMemoryUsage(props) {
+        return this.metric('EnvironmentMaxMemoryUsage', { statistic: cloudwatch.Stats.MAXIMUM, ...props });
+    }
+    /** Bytes sent in responses (`ResponseBytes`). */
+    metricResponseBytes(props) {
+        return this.metric('ResponseBytes', props);
+    }
+    createEndpoint(id, options, namePrefix, nameSeed) {
+        if (this.endpoints.length >= MAX_ENDPOINTS) {
+            throw new Error(`${this.node.path}: a Web Function can have at most ${MAX_ENDPOINTS} endpoints`);
+        }
+        const endpoint = web_function_endpoint_1.WebFunctionEndpoint._create(this, id, {
+            ...options,
+            webFunction: this,
+            currentRevision: this.currentRevision,
+            namePrefix,
+            nameSeed,
+        });
+        const clash = this.endpoints.find((e) => !aws_cdk_lib_1.Token.isUnresolved(e.endpointName) && e.endpointName === endpoint.endpointName);
+        if (clash) {
+            throw new Error(`${endpoint.node.path}: endpointName '${endpoint.endpointName}' is already used by ${clash.node.path}`);
+        }
+        this.endpoints.push(endpoint);
+        // Revisions an endpoint stops routing to only become deletable once it's updated.
+        this.revisionCleanup.node.addDependency(endpoint);
+        // Each serving region's .local group must exist before traffic, and outlive the function.
+        for (const region of endpoint.regions.slice(1)) {
+            if (this.remoteLogGroups.has(region))
+                continue;
+            const group = this.logGroupIn(`LocalLogs-${region}`, region, `${this.logGroupName}.local`);
+            this.remoteLogGroups.set(region, group);
+            this.resource.node.addDependency(group.resource);
+        }
+        return endpoint;
+    }
+    createLogGroups(logGroupName) {
         const home = aws_cdk_lib_1.Stack.of(this).region;
         return [
-            this.logGroupIn('Logs', home, logGroupName, props),
-            this.logGroupIn('LocalLogs', home, `${logGroupName}.local`, props),
+            this.logGroupIn('Logs', home, logGroupName),
+            this.logGroupIn('LocalLogs', home, `${logGroupName}.local`),
         ];
     }
-    createRemoteLogGroups(logGroupName, props) {
-        return this.endpoint.regions.slice(1).map((region) => this.logGroupIn(`LocalLogs-${region}`, region, `${logGroupName}.local`, props));
-    }
-    logGroupIn(id, region, name, props) {
+    logGroupIn(id, region, name) {
         return new log_group_1.WebFunctionLogGroup(this, id, {
             region,
             logGroupName: name,
-            retention: props.logRetention ?? logs.RetentionDays.ONE_MONTH,
-            removalPolicy: props.logRemovalPolicy ?? aws_cdk_lib_1.RemovalPolicy.RETAIN,
+            retention: this.logOptions.logRetention ?? logs.RetentionDays.ONE_MONTH,
+            removalPolicy: this.logOptions.logRemovalPolicy ?? aws_cdk_lib_1.RemovalPolicy.RETAIN,
         });
     }
 }
 exports.WebFunction = WebFunction;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"web-function.js","sourceRoot":"","sources":["../src/web-function.ts"],"names":[],"mappings":"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","sourcesContent":["import { Duration, type IResource, Lazy, Names, RemovalPolicy, Resource, 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 * as logs from 'aws-cdk-lib/aws-logs';\nimport { Construct } from 'constructs';\nimport { WebFunctionAuthType } from './enums';\nimport { WebFunctionCode } from './private/code';\nimport { WebFunctionLogGroup } from './private/log-group';\nimport { CFN_VALIDATE_UNKNOWN_TYPE, assertResourceName } from './private/validation';\nimport { WebFunctionEndpoint, type WebFunctionEndpointOptions } from './web-function-endpoint';\nimport { WebFunctionGrants } from './web-function-grants';\n\n/**\n * Options shared by `WebFunction` and `NodejsWebFunction`: everything except how the code is supplied.\n */\nexport interface WebFunctionOptions {\n  /**\n   * How callers of the endpoint are authenticated.\n   */\n  readonly authType: WebFunctionAuthType;\n\n  /**\n   * The endpoint: where it serves from, and its name.\n   *\n   * @default - a HOME_REGION endpoint\n   */\n  readonly endpoint?: WebFunctionEndpointOptions;\n\n  /**\n   * The function's name. Renaming a function replaces it, and its endpoint gets a new URL.\n   *\n   * @default - a unique name generated from the construct path (moving the construct changes it)\n   */\n  readonly webFunctionName?: string;\n\n  /**\n   * A description of the function's code and configuration.\n   *\n   * @default - no description\n   */\n  readonly description?: string;\n\n  /**\n   * The execution role.\n   *\n   * An `iam.IRole` (not `IRoleRef`) because the function adds statements to it and grants through it.\n   * [disable-awslint:prefer-ref-interface]\n   *\n   * @default - a role trusting `lambda.amazonaws.com` with `AWSLambdaBasicExecutionRole`\n   */\n  readonly role?: iam.IRole;\n\n  /**\n   * Environment variables. Names starting with `AWS_` are reserved.\n   *\n   * @default - none\n   */\n  readonly environment?: { [key: string]: string };\n\n  /**\n   * How long a single request may run.\n   *\n   * @default Duration.seconds(30)\n   */\n  readonly timeout?: Duration;\n\n  /**\n   * How many requests one execution environment handles at the same time (1-128).\n   * Requests share module-level state, so handlers must be concurrency-safe.\n   *\n   * @default 64\n   */\n  readonly maxConcurrencyPerEnvironment?: number;\n\n  /**\n   * Retention for every log group of the function, in every region it serves from.\n   *\n   * @default logs.RetentionDays.ONE_MONTH\n   */\n  readonly logRetention?: logs.RetentionDays;\n\n  /**\n   * What happens to the log groups when the function is removed: RETAIN or DESTROY.\n   * With DESTROY, deletion waits about a minute for environments to flush their last lines.\n   *\n   * @default RemovalPolicy.RETAIN\n   */\n  readonly logRemovalPolicy?: RemovalPolicy;\n\n  /**\n   * The minimum level of application logs to keep.\n   *\n   * @default lambda.ApplicationLogLevel.INFO\n   */\n  readonly applicationLogLevelV2?: lambda.ApplicationLogLevel;\n\n  /**\n   * The minimum level of platform logs to keep (DEBUG, INFO or WARN).\n   *\n   * @default lambda.SystemLogLevel.INFO\n   */\n  readonly systemLogLevelV2?: lambda.SystemLogLevel;\n}\n\n/**\n * Properties for a `WebFunction`.\n */\nexport interface WebFunctionProps extends WebFunctionOptions {\n  /**\n   * The Node.js runtime, e.g. `lambda.Runtime.NODEJS_24_X`.\n   */\n  readonly runtime: lambda.Runtime;\n\n  /**\n   * The code: a zip in S3 (`Code.fromAsset`, `Code.fromBucket`, `Code.fromCustomCommand`, `Code.fromDockerBuild`).\n   * Inline code and container images aren't supported.\n   *\n   * The code is copied into the stack's code bucket, which Lambda Web Functions can read.\n   */\n  readonly code: lambda.Code;\n\n  /**\n   * The file that starts your server, relative to the root of the code.\n   *\n   * @default 'index.js'\n   */\n  readonly entrypoint?: string;\n\n}\n\n/**\n * A Lambda Web Function.\n */\nexport interface IWebFunction extends IResource, lambda.IWebFunctionRef {\n  /**\n   * The function's name.\n   *\n   * @attribute\n   */\n  readonly webFunctionName: string;\n\n  /**\n   * The function's ARN.\n   *\n   * @attribute\n   */\n  readonly webFunctionArn: string;\n}\n\n/**\n * A Node.js HTTP server running as an AWS Lambda Web Function, served from one or more regions.\n *\n * Creates the function, its current revision (code and configuration; any change replaces it),\n * an HTTPS endpoint, an execution role, and owns the function's log groups in every region.\n *\n * Importing existing functions (`fromXxx` methods) is planned after 0.1.\n *\n * @resource AWS::Lambda::WebFunction\n */\nexport class WebFunction extends Resource implements IWebFunction, iam.IGrantable {\n  public readonly webFunctionName: string;\n  public readonly webFunctionArn: string;\n\n  /** The ID of the current revision. */\n  public readonly revisionId: string;\n\n  /** The function's endpoint. */\n  public readonly endpoint: WebFunctionEndpoint;\n\n  /** Grants on the function (e.g. `grants.invoke(principal)`). */\n  public readonly grants: WebFunctionGrants;\n\n  /** The execution role. */\n  public readonly role: iam.IRole;\n\n  /** The principal to grant permissions to (the execution role). */\n  public readonly grantPrincipal: iam.IPrincipal;\n\n  /**\n   * The home-region log group that receives the logs of every region the function serves from.\n   * Subscribe to this one only: each region's `.local` group holds a copy of the same events.\n   */\n  public readonly logGroup: logs.ILogGroup;\n\n  private readonly environment: { [key: string]: string } = {};\n\n  /** A reference to this function, for APIs that accept `lambda.IWebFunctionRef`. */\n  public get webFunctionRef(): lambda.WebFunctionReference {\n    return { functionArn: this.webFunctionArn };\n  }\n\n  constructor(scope: Construct, id: string, props: WebFunctionProps) {\n    super(scope, id);\n\n    if (props.runtime.family !== lambda.RuntimeFamily.NODEJS) {\n      throw new Error(`${this.node.path}: Lambda Web Functions run Node.js only, got ${props.runtime.name}`);\n    }\n    const timeout = props.timeout?.toSeconds() ?? 30;\n    if (!Token.isUnresolved(timeout) && (timeout < 3 || timeout > 900)) {\n      throw new Error(`${this.node.path}: timeout must be between 3 seconds and 15 minutes, got ${timeout}s`);\n    }\n    const maxConcurrency = props.maxConcurrencyPerEnvironment;\n    const validConcurrency = (n: number) => Number.isInteger(n) && n >= 1 && n <= 128;\n    if (maxConcurrency !== undefined && !Token.isUnresolved(maxConcurrency) && !validConcurrency(maxConcurrency)) {\n      throw new Error(`${this.node.path}: maxConcurrencyPerEnvironment must be an integer from 1 to 128, got ${maxConcurrency}`);\n    }\n    const systemLogLevels = [lambda.SystemLogLevel.DEBUG, lambda.SystemLogLevel.INFO, lambda.SystemLogLevel.WARN];\n    if (props.systemLogLevelV2 !== undefined && !systemLogLevels.includes(props.systemLogLevelV2)) {\n      throw new Error(`${this.node.path}: systemLogLevelV2 must be DEBUG, INFO or WARN for Lambda Web Functions`);\n    }\n\n    this.webFunctionName = props.webFunctionName ?? Names.uniqueResourceName(this, { maxLength: 64, separator: '-' });\n    assertResourceName(this, 'webFunctionName', this.webFunctionName);\n\n    for (const [key, value] of Object.entries(props.environment ?? {})) {\n      this.addEnvironment(key, value);\n    }\n    if (props.entrypoint !== undefined) {\n      this.environment.AWS_LAMBDA_NODEJS_ENTRYPOINT = props.entrypoint;\n    }\n\n    this.role = props.role ?? new iam.Role(this, 'ServiceRole', {\n      assumedBy: new iam.ServicePrincipal('lambda.amazonaws.com'),\n      managedPolicies: [iam.ManagedPolicy.fromAwsManagedPolicyName('service-role/AWSLambdaBasicExecutionRole')],\n    });\n    this.grantPrincipal = this.role;\n\n    // Log groups first: the service would otherwise create them without retention.\n    const logGroupName = `/aws/lambda/web/${this.webFunctionName}`;\n    const logGroups = this.createLogGroups(logGroupName, props);\n    this.logGroup = logs.LogGroup.fromLogGroupName(this, 'LogGroup', logGroupName);\n\n    const code = new WebFunctionCode(this, 'Code', props.code).location;\n\n    const fn = new lambda.CfnWebFunction(this, 'Resource', { functionName: this.webFunctionName });\n    // The function is deleted before its log groups, which then wait for late flushes.\n    for (const group of logGroups) fn.node.addDependency(group.resource);\n    Validations.of(fn).acknowledge(CFN_VALIDATE_UNKNOWN_TYPE);\n    this.webFunctionArn = fn.attrFunctionArn;\n\n    const revision = new lambda.CfnWebFunctionRevision(this, 'Revision', {\n      functionName: fn.attrFunctionArn,\n      description: props.description,\n      buildConfig: {\n        codeConfig: { s3Object: { bucket: code.bucketName, key: code.objectKey, versionId: code.objectVersion } },\n        runtimeConfig: { runtime: props.runtime.name },\n      },\n      serviceConfig: {\n        executionRoleArn: this.role.roleArn,\n        environmentVariables: Lazy.any({ produce: () => (Object.keys(this.environment).length > 0 ? { ...this.environment } : undefined) }),\n        timeoutSeconds: timeout,\n        maxConcurrencyPerEnvironment: maxConcurrency,\n        telemetryConfig: {\n          loggingConfig: {\n            logGroup: logGroupName,\n            applicationLogLevel: props.applicationLogLevelV2,\n            systemLogLevel: props.systemLogLevelV2,\n          },\n        },\n      },\n    });\n    // Wait for the role's policies, so the first environment starts with its permissions.\n    revision.node.addDependency(this.role);\n    Validations.of(revision).acknowledge(CFN_VALIDATE_UNKNOWN_TYPE);\n    this.revisionId = revision.attrRevisionId;\n\n    this.endpoint = WebFunctionEndpoint._create(this, 'Endpoint', {\n      ...props.endpoint,\n      functionName: this.webFunctionName,\n      functionArn: fn.attrFunctionArn,\n      revisionId: revision.attrRevisionId,\n      authType: props.authType,\n    });\n\n    this.grants = WebFunctionGrants._forEndpoint(this.endpoint);\n\n    // Remote regions' .local groups can only be created once the regions are known.\n    for (const group of this.createRemoteLogGroups(logGroupName, props)) fn.node.addDependency(group.resource);\n  }\n\n  /**\n   * Adds an environment variable. Names starting with `AWS_` are reserved.\n   */\n  public addEnvironment(key: string, value: string): WebFunction {\n    if (key.startsWith('AWS_')) {\n      throw new Error(`${this.node.path}: environment variable ${key} is reserved (names starting with AWS_ are set by the runtime)${key === 'AWS_LAMBDA_NODEJS_ENTRYPOINT' ? '; use the entrypoint property' : ''}`);\n    }\n    this.environment[key] = value;\n    return this;\n  }\n\n  /**\n   * Adds a statement to the execution role's policy.\n   */\n  public addToRolePolicy(statement: iam.PolicyStatement): void {\n    this.role.addToPrincipalPolicy(statement);\n  }\n\n  /**\n   * Allows `grantee` to call the endpoint. Shortcut for `grants.invoke(grantee)`, as on `lambda.Function`.\n   * [disable-awslint:no-grants]\n   */\n  public grantInvoke(grantee: iam.IGrantable): iam.Grant {\n    return this.grants.invoke(grantee);\n  }\n\n  private createLogGroups(logGroupName: string, props: WebFunctionProps): WebFunctionLogGroup[] {\n    const home = Stack.of(this).region;\n    return [\n      this.logGroupIn('Logs', home, logGroupName, props),\n      this.logGroupIn('LocalLogs', home, `${logGroupName}.local`, props),\n    ];\n  }\n\n  private createRemoteLogGroups(logGroupName: string, props: WebFunctionProps): WebFunctionLogGroup[] {\n    return this.endpoint.regions.slice(1).map((region) => this.logGroupIn(`LocalLogs-${region}`, region, `${logGroupName}.local`, props));\n  }\n\n  private logGroupIn(id: string, region: string, name: string, props: WebFunctionProps): WebFunctionLogGroup {\n    return new WebFunctionLogGroup(this, id, {\n      region,\n      logGroupName: name,\n      retention: props.logRetention ?? logs.RetentionDays.ONE_MONTH,\n      removalPolicy: props.logRemovalPolicy ?? RemovalPolicy.RETAIN,\n    });\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"web-function.js","sourceRoot":"","sources":["../src/web-function.ts"],"names":[],"mappings":"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","sourcesContent":["import { Duration, type IResource, Lazy, Names, RemovalPolicy, Resource, 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 * as logs from 'aws-cdk-lib/aws-logs';\nimport { Construct } from 'constructs';\nimport { WebFunctionAuthType } from './enums';\nimport { WebFunctionCode } from './private/code';\nimport { WebFunctionLogGroup } from './private/log-group';\nimport { DEFAULT_PERIOD, WEB_NAMESPACE } from './private/metrics';\nimport { RevisionCleanup } from './private/revision-cleanup';\nimport { CFN_VALIDATE_UNKNOWN_TYPE, assertResourceName } from './private/validation';\nimport { WebFunctionEndpoint, type AddWebFunctionEndpointOptions, type WebFunctionEndpointOptions } from './web-function-endpoint';\nimport { WebFunctionGrants } from './web-function-grants';\nimport { WebFunctionRevision, type IWebFunctionRevision } from './web-function-revision';\n\n/** Endpoints per function (service quota, not adjustable). */\nconst MAX_ENDPOINTS = 10;\n\n/**\n * Options shared by `WebFunction` and `NodejsWebFunction`: everything except how the code is supplied.\n */\nexport interface WebFunctionOptions {\n  /**\n   * How callers of the endpoint are authenticated.\n   */\n  readonly authType: WebFunctionAuthType;\n\n  /**\n   * The default endpoint (`fn.endpoint`): where it serves from, its name and limits.\n   * It serves the current revision; route it elsewhere with `fn.endpoint.routeTraffic()`.\n   * Add more endpoints with `addEndpoint`.\n   *\n   * @default - a HOME_REGION endpoint serving the current revision\n   */\n  readonly endpoint?: WebFunctionEndpointOptions;\n\n  /**\n   * How many of the newest revisions to keep (1-50). Each deployment that changes the code or\n   * configuration creates a revision; older ones stay available to roll back to or route traffic to,\n   * and the oldest beyond this count are deleted after each deployment.\n   *\n   * Revisions that an endpoint routes to are never deleted, and neither are those the previous\n   * deployment used (a rollback returns to them).\n   *\n   * @default 20\n   */\n  readonly revisionRetention?: number;\n\n  /**\n   * The function's name. Renaming a function replaces it, and its endpoint gets a new URL.\n   *\n   * @default - a unique name generated from the construct path (moving the construct changes it)\n   */\n  readonly webFunctionName?: string;\n\n  /**\n   * A description of the function's code and configuration.\n   *\n   * @default - no description\n   */\n  readonly description?: string;\n\n  /**\n   * The execution role.\n   *\n   * An `iam.IRole` (not `IRoleRef`) because the function adds statements to it and grants through it.\n   * [disable-awslint:prefer-ref-interface]\n   *\n   * @default - a role trusting `lambda.amazonaws.com` with `AWSLambdaBasicExecutionRole`\n   */\n  readonly role?: iam.IRole;\n\n  /**\n   * Environment variables. Names starting with `AWS_` are reserved.\n   *\n   * @default - none\n   */\n  readonly environment?: { [key: string]: string };\n\n  /**\n   * How long a single request may run.\n   *\n   * @default Duration.seconds(30)\n   */\n  readonly timeout?: Duration;\n\n  /**\n   * How many requests one execution environment handles at the same time (1-128).\n   * Requests share module-level state, so handlers must be concurrency-safe.\n   *\n   * @default 64\n   */\n  readonly maxConcurrencyPerEnvironment?: number;\n\n  /**\n   * Retention for every log group of the function, in every region it serves from.\n   *\n   * @default logs.RetentionDays.ONE_MONTH\n   */\n  readonly logRetention?: logs.RetentionDays;\n\n  /**\n   * What happens to the log groups when the function is removed: RETAIN or DESTROY.\n   * With DESTROY, deletion waits about a minute for environments to flush their last lines.\n   *\n   * @default RemovalPolicy.RETAIN\n   */\n  readonly logRemovalPolicy?: RemovalPolicy;\n\n  /**\n   * The minimum level of application logs to keep.\n   *\n   * @default lambda.ApplicationLogLevel.INFO\n   */\n  readonly applicationLogLevelV2?: lambda.ApplicationLogLevel;\n\n  /**\n   * The minimum level of platform logs to keep (DEBUG, INFO or WARN).\n   *\n   * @default lambda.SystemLogLevel.INFO\n   */\n  readonly systemLogLevelV2?: lambda.SystemLogLevel;\n}\n\n/**\n * Properties for a `WebFunction`.\n */\nexport interface WebFunctionProps extends WebFunctionOptions {\n  /**\n   * The Node.js runtime, e.g. `lambda.Runtime.NODEJS_24_X`.\n   */\n  readonly runtime: lambda.Runtime;\n\n  /**\n   * The code: a zip in S3 (`Code.fromAsset`, `Code.fromBucket`, `Code.fromCustomCommand`, `Code.fromDockerBuild`).\n   * Inline code and container images aren't supported.\n   *\n   * The code is copied into the stack's code bucket, which Lambda Web Functions can read.\n   */\n  readonly code: lambda.Code;\n\n  /**\n   * The file that starts your server, relative to the root of the code.\n   *\n   * @default 'index.js'\n   */\n  readonly entrypoint?: string;\n\n}\n\n/**\n * A Lambda Web Function.\n */\nexport interface IWebFunction extends IResource, lambda.IWebFunctionRef {\n  /**\n   * The function's name.\n   *\n   * @attribute\n   */\n  readonly webFunctionName: string;\n\n  /**\n   * The function's ARN.\n   *\n   * @attribute\n   */\n  readonly webFunctionArn: string;\n}\n\n/**\n * A Node.js HTTP server running as an AWS Lambda Web Function, served from one or more regions.\n *\n * Creates the function, its current revision (code and configuration; any change creates a new one,\n * and the newest `revisionRetention` are kept), a default HTTPS endpoint, an execution role, and owns\n * the function's log groups in every region its endpoints serve from.\n *\n * Importing existing functions (`fromXxx` methods) is planned after 0.1.\n *\n * @resource AWS::Lambda::WebFunction\n */\nexport class WebFunction extends Resource implements IWebFunction, iam.IGrantable {\n  public readonly webFunctionName: string;\n  public readonly webFunctionArn: string;\n\n  /** The ID of the current revision. Same as `currentRevision.revisionId`. */\n  public readonly revisionId: string;\n\n  /** The revision built from the current code and configuration. */\n  public readonly currentRevision: IWebFunctionRevision;\n\n  /** The default endpoint. Add more with `addEndpoint`. */\n  public readonly endpoint: WebFunctionEndpoint;\n\n  /** Grants on the default endpoint (e.g. `grants.invoke(principal)`). Other endpoints have their own `grants`. */\n  public readonly grants: WebFunctionGrants;\n\n  /** The execution role. */\n  public readonly role: iam.IRole;\n\n  /** The principal to grant permissions to (the execution role). */\n  public readonly grantPrincipal: iam.IPrincipal;\n\n  /**\n   * The home-region log group that receives the logs of every region the function serves from.\n   * Subscribe to this one only: each region's `.local` group holds a copy of the same events.\n   */\n  public readonly logGroup: logs.ILogGroup;\n\n  private readonly environment: { [key: string]: string } = {};\n  private readonly endpoints: WebFunctionEndpoint[] = [];\n  private readonly remoteLogGroups = new Map<string, WebFunctionLogGroup>();\n  private readonly logGroupName: string;\n  private readonly logOptions: Pick<WebFunctionProps, 'logRetention' | 'logRemovalPolicy'>;\n  private readonly resource: lambda.CfnWebFunction;\n  private readonly revisionCleanup: RevisionCleanup;\n\n  /** A reference to this function, for APIs that accept `lambda.IWebFunctionRef`. */\n  public get webFunctionRef(): lambda.WebFunctionReference {\n    return { functionArn: this.webFunctionArn };\n  }\n\n  constructor(scope: Construct, id: string, props: WebFunctionProps) {\n    super(scope, id);\n\n    if (props.runtime.family !== lambda.RuntimeFamily.NODEJS) {\n      throw new Error(`${this.node.path}: Lambda Web Functions run Node.js only, got ${props.runtime.name}`);\n    }\n    const timeout = props.timeout?.toSeconds() ?? 30;\n    if (!Token.isUnresolved(timeout) && (timeout < 3 || timeout > 900)) {\n      throw new Error(`${this.node.path}: timeout must be between 3 seconds and 15 minutes, got ${timeout}s`);\n    }\n    const maxConcurrency = props.maxConcurrencyPerEnvironment;\n    const validConcurrency = (n: number) => Number.isInteger(n) && n >= 1 && n <= 128;\n    if (maxConcurrency !== undefined && !Token.isUnresolved(maxConcurrency) && !validConcurrency(maxConcurrency)) {\n      throw new Error(`${this.node.path}: maxConcurrencyPerEnvironment must be an integer from 1 to 128, got ${maxConcurrency}`);\n    }\n    const revisionRetention = props.revisionRetention ?? 20;\n    if (!Token.isUnresolved(revisionRetention) && (!Number.isInteger(revisionRetention) || revisionRetention < 1 || revisionRetention > 50)) {\n      throw new Error(`${this.node.path}: revisionRetention must be an integer from 1 to 50, got ${revisionRetention}`);\n    }\n    const systemLogLevels = [lambda.SystemLogLevel.DEBUG, lambda.SystemLogLevel.INFO, lambda.SystemLogLevel.WARN];\n    if (props.systemLogLevelV2 !== undefined && !systemLogLevels.includes(props.systemLogLevelV2)) {\n      throw new Error(`${this.node.path}: systemLogLevelV2 must be DEBUG, INFO or WARN for Lambda Web Functions`);\n    }\n\n    this.webFunctionName = props.webFunctionName ?? Names.uniqueResourceName(this, { maxLength: 64, separator: '-' });\n    assertResourceName(this, 'webFunctionName', this.webFunctionName);\n\n    for (const [key, value] of Object.entries(props.environment ?? {})) {\n      this.addEnvironment(key, value);\n    }\n    if (props.entrypoint !== undefined) {\n      this.environment.AWS_LAMBDA_NODEJS_ENTRYPOINT = props.entrypoint;\n    }\n\n    this.role = props.role ?? new iam.Role(this, 'ServiceRole', {\n      assumedBy: new iam.ServicePrincipal('lambda.amazonaws.com'),\n      managedPolicies: [iam.ManagedPolicy.fromAwsManagedPolicyName('service-role/AWSLambdaBasicExecutionRole')],\n    });\n    this.grantPrincipal = this.role;\n\n    // Log groups first: the service would otherwise create them without retention.\n    const logGroupName = `/aws/lambda/web/${this.webFunctionName}`;\n    this.logGroupName = logGroupName;\n    this.logOptions = { logRetention: props.logRetention, logRemovalPolicy: props.logRemovalPolicy };\n    const logGroups = this.createLogGroups(logGroupName);\n    this.logGroup = logs.LogGroup.fromLogGroupName(this, 'LogGroup', logGroupName);\n\n    const code = new WebFunctionCode(this, 'Code', props.code).location;\n\n    const fn = new lambda.CfnWebFunction(this, 'Resource', { functionName: this.webFunctionName });\n    // The function is deleted before its log groups, which then wait for late flushes.\n    for (const group of logGroups) fn.node.addDependency(group.resource);\n    Validations.of(fn).acknowledge(CFN_VALIDATE_UNKNOWN_TYPE);\n    this.resource = fn;\n    this.webFunctionArn = fn.attrFunctionArn;\n\n    const revision = new lambda.CfnWebFunctionRevision(this, 'Revision', {\n      functionName: fn.attrFunctionArn,\n      description: props.description,\n      buildConfig: {\n        codeConfig: { s3Object: { bucket: code.bucketName, key: code.objectKey, versionId: code.objectVersion } },\n        runtimeConfig: { runtime: props.runtime.name },\n      },\n      serviceConfig: {\n        executionRoleArn: this.role.roleArn,\n        environmentVariables: Lazy.any({ produce: () => (Object.keys(this.environment).length > 0 ? { ...this.environment } : undefined) }),\n        timeoutSeconds: timeout,\n        maxConcurrencyPerEnvironment: maxConcurrency,\n        telemetryConfig: {\n          loggingConfig: {\n            logGroup: logGroupName,\n            applicationLogLevel: props.applicationLogLevelV2,\n            systemLogLevel: props.systemLogLevelV2,\n          },\n        },\n      },\n    });\n    // Wait for the role's policies, so the first environment starts with its permissions.\n    revision.node.addDependency(this.role);\n    Validations.of(revision).acknowledge(CFN_VALIDATE_UNKNOWN_TYPE);\n    // Replaced revisions stay as rollback targets; RevisionCleanup deletes the oldest. Deleting the function deletes them all.\n    revision.applyRemovalPolicy(RemovalPolicy.RETAIN);\n    this.revisionId = revision.attrRevisionId;\n    this.currentRevision = WebFunctionRevision._current(this, 'CurrentRevision', this, revision.attrRevisionId, revision.attrRevisionArn);\n\n    this.revisionCleanup = new RevisionCleanup(this, 'RevisionCleanup', {\n      functionName: this.webFunctionName,\n      functionArn: fn.attrFunctionArn,\n      keep: revisionRetention,\n      revisionIds: () => [this.currentRevision.revisionId, ...this.endpoints.flatMap((e) => e._revisionIds())],\n    });\n\n    this.endpoint = this.createEndpoint('Endpoint', { ...props.endpoint, authType: props.authType }, 'default');\n    this.grants = this.endpoint.grants;\n  }\n\n  /**\n   * Adds an endpoint (up to 10 per function), e.g. a public one next to an IAM-only one, or one pinned to an\n   * earlier revision. Each endpoint has its own URL, authentication, regions and limits.\n   *\n   * @param id the endpoint's construct ID, also used in its generated name (`<id>-<hash>`)\n   */\n  public addEndpoint(id: string, options: AddWebFunctionEndpointOptions): WebFunctionEndpoint {\n    const prefix = id.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-+/, '').slice(0, 55).replace(/-+$/, '') || 'endpoint';\n    return this.createEndpoint(id, options, prefix, id);\n  }\n\n  /**\n   * Adds an environment variable. Names starting with `AWS_` are reserved.\n   */\n  public addEnvironment(key: string, value: string): WebFunction {\n    if (key.startsWith('AWS_')) {\n      throw new Error(`${this.node.path}: environment variable ${key} is reserved (names starting with AWS_ are set by the runtime)${key === 'AWS_LAMBDA_NODEJS_ENTRYPOINT' ? '; use the entrypoint property' : ''}`);\n    }\n    this.environment[key] = value;\n    return this;\n  }\n\n  /**\n   * Adds a statement to the execution role's policy.\n   */\n  public addToRolePolicy(statement: iam.PolicyStatement): void {\n    this.role.addToPrincipalPolicy(statement);\n  }\n\n  /**\n   * Allows `grantee` to call the endpoint. Shortcut for `grants.invoke(grantee)`, as on `lambda.Function`.\n   * [disable-awslint:no-grants]\n   */\n  public grantInvoke(grantee: iam.IGrantable): iam.Grant {\n    return this.grants.invoke(grantee);\n  }\n\n  /**\n   * A metric of this function's execution environments in `AWS/Lambda/Web` (dimension `FunctionName`), across all endpoints.\n   * For request and error counts, use the endpoint's metrics (`fn.endpoint.metricRequests()`).\n   *\n   * Metrics are published in the region that served the request: pass `region` for another serving region.\n   * 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: { FunctionName: this.webFunctionName },\n      statistic: cloudwatch.Stats.SUM,\n      period: DEFAULT_PERIOD,\n      ...props,\n    });\n  }\n\n  /** Time the execution environments were active (`EnvironmentActiveTime`). */\n  public metricActiveTime(props?: cloudwatch.MetricOptions): cloudwatch.Metric {\n    return this.metric('EnvironmentActiveTime', props);\n  }\n\n  /** CPU time the execution environments used (`EnvironmentCPUTime`). */\n  public metricCpuTime(props?: cloudwatch.MetricOptions): cloudwatch.Metric {\n    return this.metric('EnvironmentCPUTime', props);\n  }\n\n  /**\n   * Requests an execution environment handled at once (`EnvironmentConcurrentRequests`), to compare with\n   * `maxConcurrencyPerEnvironment`.\n   *\n   * @default - maximum over 1 minute\n   */\n  public metricConcurrentRequests(props?: cloudwatch.MetricOptions): cloudwatch.Metric {\n    return this.metric('EnvironmentConcurrentRequests', { statistic: cloudwatch.Stats.MAXIMUM, ...props });\n  }\n\n  /**\n   * Peak memory an execution environment used (`EnvironmentMaxMemoryUsage`); each environment has 2 GB.\n   *\n   * @default - maximum over 1 minute\n   */\n  public metricMaxMemoryUsage(props?: cloudwatch.MetricOptions): cloudwatch.Metric {\n    return this.metric('EnvironmentMaxMemoryUsage', { statistic: cloudwatch.Stats.MAXIMUM, ...props });\n  }\n\n  /** Bytes sent in responses (`ResponseBytes`). */\n  public metricResponseBytes(props?: cloudwatch.MetricOptions): cloudwatch.Metric {\n    return this.metric('ResponseBytes', props);\n  }\n\n  private createEndpoint(id: string, options: AddWebFunctionEndpointOptions, namePrefix: string, nameSeed?: string): WebFunctionEndpoint {\n    if (this.endpoints.length >= MAX_ENDPOINTS) {\n      throw new Error(`${this.node.path}: a Web Function can have at most ${MAX_ENDPOINTS} endpoints`);\n    }\n    const endpoint = WebFunctionEndpoint._create(this, id, {\n      ...options,\n      webFunction: this,\n      currentRevision: this.currentRevision,\n      namePrefix,\n      nameSeed,\n    });\n    const clash = this.endpoints.find((e) => !Token.isUnresolved(e.endpointName) && e.endpointName === endpoint.endpointName);\n    if (clash) {\n      throw new Error(`${endpoint.node.path}: endpointName '${endpoint.endpointName}' is already used by ${clash.node.path}`);\n    }\n    this.endpoints.push(endpoint);\n    // Revisions an endpoint stops routing to only become deletable once it's updated.\n    this.revisionCleanup.node.addDependency(endpoint);\n    // Each serving region's .local group must exist before traffic, and outlive the function.\n    for (const region of endpoint.regions.slice(1)) {\n      if (this.remoteLogGroups.has(region)) continue;\n      const group = this.logGroupIn(`LocalLogs-${region}`, region, `${this.logGroupName}.local`);\n      this.remoteLogGroups.set(region, group);\n      this.resource.node.addDependency(group.resource);\n    }\n    return endpoint;\n  }\n\n  private createLogGroups(logGroupName: string): WebFunctionLogGroup[] {\n    const home = Stack.of(this).region;\n    return [\n      this.logGroupIn('Logs', home, logGroupName),\n      this.logGroupIn('LocalLogs', home, `${logGroupName}.local`),\n    ];\n  }\n\n  private logGroupIn(id: string, region: string, name: string): WebFunctionLogGroup {\n    return new WebFunctionLogGroup(this, id, {\n      region,\n      logGroupName: name,\n      retention: this.logOptions.logRetention ?? logs.RetentionDays.ONE_MONTH,\n      removalPolicy: this.logOptions.logRemovalPolicy ?? RemovalPolicy.RETAIN,\n    });\n  }\n}\n"]}

package/package.json

@@ -46,6 +46,8 @@
     "@aws-cdk/integ-runner": "latest",
     "@aws-cdk/integ-tests-alpha": "latest",
     "@aws-crypto/sha256-js": "^5.2.0",
+    "@aws-sdk/client-cloudformation": "^3",
+    "@aws-sdk/client-cloudwatch": "^3",
     "@aws-sdk/client-cloudwatch-logs": "^3",
     "@aws-sdk/client-lambda-web": "^3.1151.0",
     "@aws-sdk/client-s3": "^3",
@@ -76,7 +78,7 @@
     "jsii-docgen": "^10.5.0",
     "jsii-pacmak": "^1.141.0",
     "jsii-rosetta": "~6.0.0",
-    "projen": "^0.104.5",
+    "projen": "^0.104.8",
     "supports-color": "^7",
     "ts-jest": "^29.4.15",
     "ts-node": "^10.9.2",
@@ -109,7 +111,7 @@
   "main": "lib/index.js",
   "license": "Apache-2.0",
   "stability": "experimental",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "jest": {
     "coverageProvider": "v8",
     "testMatch": [
@@ -165,6 +167,7 @@
   "awslint": {
     "exclude": [
       "construct-ctor:@ashishpandeyone/cdk-lambda-web-function.WebFunctionEndpoint",
+      "construct-ctor:@ashishpandeyone/cdk-lambda-web-function.WebFunctionRevision",
       "from-method:@ashishpandeyone/cdk-lambda-web-function.WebFunction",
       "resource-interface:@ashishpandeyone/cdk-lambda-web-function.NodejsWebFunction"
     ]