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

package/lib/private/provider-protocol.js

@@ -7,7 +7,7 @@
  * CloudFormation passes every scalar property to the handler as a string.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ENDPOINT_LOOKUP_RESOURCE_TYPE = exports.LOG_GROUP_RESOURCE_TYPE = exports.CODE_RESOURCE_TYPE = void 0;
+exports.TRAFFIC_SHIFT_RESOURCE_TYPE = exports.REVISION_CLEANUP_RESOURCE_TYPE = exports.ENDPOINT_LOOKUP_RESOURCE_TYPE = exports.LOG_GROUP_RESOURCE_TYPE = exports.CODE_RESOURCE_TYPE = void 0;
 exports.regionalDomainAttribute = regionalDomainAttribute;
 /** Copies a code zip into the stack's code bucket and returns the object's version. */
 exports.CODE_RESOURCE_TYPE = 'Custom::LambdaWebCode';
@@ -19,4 +19,11 @@ exports.ENDPOINT_LOOKUP_RESOURCE_TYPE = 'Custom::LambdaWebEndpointLookup';
 function regionalDomainAttribute(region) {
     return `Domain.${region}`;
 }
-//# sourceMappingURL=data:application/json;base64,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
+/** Deletes a function's oldest revisions beyond a count, except those that are in use or may be rolled back to. */
+exports.REVISION_CLEANUP_RESOURCE_TYPE = 'Custom::LambdaWebRevisionCleanup';
+/**
+ * Moves an endpoint's traffic to a revision in steps, watching alarms (canary and linear deployments).
+ * Served by the deployment provider (`handlers/web-function-deployment`), not the shared provider: it can run for up to an hour.
+ */
+exports.TRAFFIC_SHIFT_RESOURCE_TYPE = 'Custom::LambdaWebTrafficShift';
+//# sourceMappingURL=data:application/json;base64,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

package/lib/private/provider.js

@@ -49,7 +49,7 @@ function webFunctionProvider(scope) {
         // Log group deletion waits for late flushes (75s + a re-check) on top of the API calls.
         timeout: aws_cdk_lib_1.Duration.minutes(5),
         memorySize: aws_cdk_lib_1.Size.mebibytes(256),
-        description: 'Copies code, manages log groups and looks up endpoints for Lambda Web Functions',
+        description: 'Copies code, manages log groups, looks up endpoints and cleans up revisions for Lambda Web Functions',
     });
 }
 const granted = new WeakMap();
@@ -74,4 +74,4 @@ function grantToProvider(provider, statement) {
     seen.add(key);
     provider.addToRolePolicy({ Effect: 'Allow', ...statement });
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/lib/private/revision-cleanup.d.ts

@@ -0,0 +1,19 @@
+import { CustomResource } from 'aws-cdk-lib';
+import { Construct } from 'constructs';
+export interface RevisionCleanupProps {
+    /** Literal function name: the provider's IAM must not reference attributes of resources that use the provider (dependency cycle). */
+    readonly functionName: string;
+    readonly functionArn: string;
+    /** How many of the newest revisions to keep. */
+    readonly keep: number;
+    /** Revisions the template uses, read when the template is synthesized (endpoints can be added later). */
+    readonly revisionIds: () => string[];
+}
+/**
+ * Deletes a function's oldest revisions beyond `keep` on every deployment. Runs after the endpoints
+ * (add them as dependencies), so the revisions they just stopped routing to are eligible.
+ */
+export declare class RevisionCleanup extends Construct {
+    readonly resource: CustomResource;
+    constructor(scope: Construct, id: string, props: RevisionCleanupProps);
+}

package/lib/private/revision-cleanup.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RevisionCleanup = void 0;
+const aws_cdk_lib_1 = require("aws-cdk-lib");
+const constructs_1 = require("constructs");
+const provider_1 = require("./provider");
+const provider_protocol_1 = require("./provider-protocol");
+/**
+ * Deletes a function's oldest revisions beyond `keep` on every deployment. Runs after the endpoints
+ * (add them as dependencies), so the revisions they just stopped routing to are eligible.
+ */
+class RevisionCleanup extends constructs_1.Construct {
+    resource;
+    constructor(scope, id, props) {
+        super(scope, id);
+        const provider = (0, provider_1.webFunctionProvider)(this);
+        // Stable grant (see grantToProvider): the function and its revisions, by name.
+        const functionArn = aws_cdk_lib_1.Stack.of(this).formatArn({
+            service: 'lambda', resource: 'web-function', resourceName: props.functionName, arnFormat: aws_cdk_lib_1.ArnFormat.SLASH_RESOURCE_NAME,
+        });
+        (0, provider_1.grantToProvider)(provider, {
+            Action: ['lambda:ListWebFunctionRevisions', 'lambda:DeleteWebFunctionRevision'],
+            Resource: [functionArn, `${functionArn}/revision/*`],
+        });
+        const properties = {
+            FunctionArn: props.functionArn,
+            Keep: String(props.keep),
+            RevisionIds: aws_cdk_lib_1.Lazy.list({ produce: () => [...new Set(props.revisionIds())] }),
+        };
+        this.resource = new aws_cdk_lib_1.CustomResource(this, 'Resource', {
+            serviceToken: provider.serviceToken,
+            resourceType: provider_protocol_1.REVISION_CLEANUP_RESOURCE_TYPE,
+            properties: { ...properties },
+        });
+    }
+}
+exports.RevisionCleanup = RevisionCleanup;
+//# sourceMappingURL=data:application/json;base64,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

package/lib/private/traffic-shift.d.ts

@@ -0,0 +1,20 @@
+import { CustomResource } from 'aws-cdk-lib';
+import { Construct } from 'constructs';
+import type { WebFunctionDeployment } from '../web-function-deployment';
+export interface TrafficShiftProps {
+    /** Literal function name, for stable IAM grants. */
+    readonly functionName: string;
+    readonly functionArn: string;
+    readonly endpointName: string;
+    readonly revisionId: string;
+    readonly deployment: WebFunctionDeployment;
+    /** The endpoint's other settings: any change makes the shift run, so it can re-check the traffic before CloudFormation writes it. */
+    readonly endpointConfig: unknown;
+}
+/**
+ * Moves an endpoint's traffic to `revisionId` in steps before CloudFormation updates the endpoint (which must depend on it).
+ */
+export declare class TrafficShift extends Construct {
+    readonly resource: CustomResource;
+    constructor(scope: Construct, id: string, props: TrafficShiftProps);
+}

package/lib/private/traffic-shift.js

@@ -0,0 +1,143 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TrafficShift = void 0;
+const node_crypto_1 = require("node:crypto");
+const path = __importStar(require("node:path"));
+const aws_cdk_lib_1 = require("aws-cdk-lib");
+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 cr = __importStar(require("aws-cdk-lib/custom-resources"));
+const constructs_1 = require("constructs");
+const provider_protocol_1 = require("./provider-protocol");
+/** The Provider framework gives up after this long and fails the deployment (with a message), before CloudFormation's own 1-hour limit. */
+const TOTAL_TIMEOUT = aws_cdk_lib_1.Duration.minutes(55);
+const PROVIDER_ID = 'LambdaWebDeploymentProvider';
+/**
+ * The stack's deployment provider: a CDK Provider framework (a Step Functions waiter) around `onEvent` and `isComplete`
+ * from `handlers/web-function-deployment`, because a canary or linear deployment can run for up to an hour.
+ * One per stack, shared by every endpoint that deploys in steps.
+ */
+class DeploymentProvider extends constructs_1.Construct {
+    static of(scope) {
+        const stack = aws_cdk_lib_1.Stack.of(scope);
+        return stack.node.tryFindChild(PROVIDER_ID) ?? new DeploymentProvider(stack, PROVIDER_ID);
+    }
+    serviceToken;
+    role;
+    granted = new Set();
+    constructor(scope, id) {
+        super(scope, id);
+        this.role = new iam.Role(this, 'Role', {
+            assumedBy: new iam.ServicePrincipal('lambda.amazonaws.com'),
+            managedPolicies: [iam.ManagedPolicy.fromAwsManagedPolicyName('service-role/AWSLambdaBasicExecutionRole')],
+        });
+        // Rollback detection: is the stack rolling back? (the provider's own stack only).
+        this.grant({ actions: ['cloudformation:DescribeStacks'], resources: [aws_cdk_lib_1.Stack.of(this).stackId] });
+        // Composite alarms are only returned with DescribeAlarms on '*'.
+        this.grant({ actions: ['cloudwatch:DescribeAlarms'], resources: ['*'] });
+        const logGroup = new logs.LogGroup(this, 'Logs', { retention: logs.RetentionDays.ONE_MONTH, removalPolicy: aws_cdk_lib_1.RemovalPolicy.DESTROY });
+        const handler = (name, handlerName, description) => new lambda.Function(this, name, {
+            runtime: lambda.Runtime.NODEJS_24_X,
+            architecture: lambda.Architecture.ARM_64,
+            code: lambda.Code.fromAsset(path.join(__dirname, '..', '..', 'assets', 'web-function-deployment')),
+            handler: `index.${handlerName}`,
+            role: this.role,
+            // isComplete waits up to 5 minutes for a restore to reach every region before failing the deployment.
+            timeout: aws_cdk_lib_1.Duration.minutes(7),
+            memorySize: 256,
+            logGroup,
+            description,
+        });
+        const provider = new cr.Provider(this, 'Provider', {
+            onEventHandler: handler('OnEvent', 'onEvent', 'Starts canary and linear deployments of Lambda Web Function endpoints'),
+            isCompleteHandler: handler('IsComplete', 'isComplete', 'Moves Lambda Web Function endpoint traffic step by step and watches alarms'),
+            queryInterval: aws_cdk_lib_1.Duration.seconds(15),
+            totalTimeout: TOTAL_TIMEOUT,
+            logGroup,
+        });
+        this.serviceToken = provider.serviceToken;
+    }
+    /**
+     * Adds a statement to the handlers' role, once. Like the shared provider's grants, they must be stable across
+     * updates (prefixes, not names that change) and never reference attributes of resources that use the provider.
+     */
+    grant(statement) {
+        const key = JSON.stringify(aws_cdk_lib_1.Stack.of(this).resolve(statement));
+        if (this.granted.has(key))
+            return;
+        this.granted.add(key);
+        this.role.addToPrincipalPolicy(new iam.PolicyStatement(statement));
+    }
+}
+/**
+ * Moves an endpoint's traffic to `revisionId` in steps before CloudFormation updates the endpoint (which must depend on it).
+ */
+class TrafficShift extends constructs_1.Construct {
+    resource;
+    constructor(scope, id, props) {
+        super(scope, id);
+        const stack = aws_cdk_lib_1.Stack.of(this);
+        const provider = DeploymentProvider.of(this);
+        const functionArn = stack.formatArn({
+            service: 'lambda', resource: 'web-function', resourceName: props.functionName, arnFormat: aws_cdk_lib_1.ArnFormat.SLASH_RESOURCE_NAME,
+        });
+        // Stable grant (see grantToProvider): every endpoint and revision of the function.
+        provider.grant({
+            actions: ['lambda:GetWebFunctionEndpoint', 'lambda:UpdateWebFunctionEndpoint'],
+            resources: [functionArn, `${functionArn}/endpoint/*`, `${functionArn}/revision/*`],
+        });
+        const deployment = props.deployment;
+        const properties = {
+            FunctionArn: props.functionArn,
+            EndpointName: props.endpointName,
+            RevisionId: props.revisionId,
+            Steps: deployment._steps.join(','),
+            WaitSeconds: String(deployment._waitSeconds),
+            AlarmArns: deployment._alarms.length > 0 ? deployment._alarms.map((a) => a.alarmArn) : undefined,
+            EndpointConfig: (0, node_crypto_1.createHash)('sha256').update(JSON.stringify(stack.resolve(props.endpointConfig))).digest('hex').slice(0, 16),
+        };
+        this.resource = new aws_cdk_lib_1.CustomResource(this, 'Resource', {
+            serviceToken: provider.serviceToken,
+            resourceType: provider_protocol_1.TRAFFIC_SHIFT_RESOURCE_TYPE,
+            properties: { ...properties },
+            // CloudFormation's maximum; the provider fails the deployment itself after 55 minutes.
+            serviceTimeout: aws_cdk_lib_1.Duration.hours(1),
+        });
+    }
+}
+exports.TrafficShift = TrafficShift;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"traffic-shift.js","sourceRoot":"","sources":["../../src/private/traffic-shift.ts"],"names":[],"mappings":"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","sourcesContent":["import { createHash } from 'node:crypto';\nimport * as path from 'node:path';\nimport { ArnFormat, CustomResource, Duration, RemovalPolicy, Stack } 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 * as cr from 'aws-cdk-lib/custom-resources';\nimport { Construct } from 'constructs';\nimport { TRAFFIC_SHIFT_RESOURCE_TYPE, type TrafficShiftProperties } from './provider-protocol';\nimport type { WebFunctionDeployment } from '../web-function-deployment';\n\n/** The Provider framework gives up after this long and fails the deployment (with a message), before CloudFormation's own 1-hour limit. */\nconst TOTAL_TIMEOUT = Duration.minutes(55);\nconst PROVIDER_ID = 'LambdaWebDeploymentProvider';\n\n/**\n * The stack's deployment provider: a CDK Provider framework (a Step Functions waiter) around `onEvent` and `isComplete`\n * from `handlers/web-function-deployment`, because a canary or linear deployment can run for up to an hour.\n * One per stack, shared by every endpoint that deploys in steps.\n */\nclass DeploymentProvider extends Construct {\n  public static of(scope: Construct): DeploymentProvider {\n    const stack = Stack.of(scope);\n    return (stack.node.tryFindChild(PROVIDER_ID) as DeploymentProvider | undefined) ?? new DeploymentProvider(stack, PROVIDER_ID);\n  }\n\n  public readonly serviceToken: string;\n  private readonly role: iam.Role;\n  private readonly granted = new Set<string>();\n\n  private constructor(scope: Construct, id: string) {\n    super(scope, id);\n    this.role = new iam.Role(this, 'Role', {\n      assumedBy: new iam.ServicePrincipal('lambda.amazonaws.com'),\n      managedPolicies: [iam.ManagedPolicy.fromAwsManagedPolicyName('service-role/AWSLambdaBasicExecutionRole')],\n    });\n    // Rollback detection: is the stack rolling back? (the provider's own stack only).\n    this.grant({ actions: ['cloudformation:DescribeStacks'], resources: [Stack.of(this).stackId] });\n    // Composite alarms are only returned with DescribeAlarms on '*'.\n    this.grant({ actions: ['cloudwatch:DescribeAlarms'], resources: ['*'] });\n\n    const logGroup = new logs.LogGroup(this, 'Logs', { retention: logs.RetentionDays.ONE_MONTH, removalPolicy: RemovalPolicy.DESTROY });\n    const handler = (name: string, handlerName: string, description: string) => new lambda.Function(this, name, {\n      runtime: lambda.Runtime.NODEJS_24_X,\n      architecture: lambda.Architecture.ARM_64,\n      code: lambda.Code.fromAsset(path.join(__dirname, '..', '..', 'assets', 'web-function-deployment')),\n      handler: `index.${handlerName}`,\n      role: this.role,\n      // isComplete waits up to 5 minutes for a restore to reach every region before failing the deployment.\n      timeout: Duration.minutes(7),\n      memorySize: 256,\n      logGroup,\n      description,\n    });\n    const provider = new cr.Provider(this, 'Provider', {\n      onEventHandler: handler('OnEvent', 'onEvent', 'Starts canary and linear deployments of Lambda Web Function endpoints'),\n      isCompleteHandler: handler('IsComplete', 'isComplete', 'Moves Lambda Web Function endpoint traffic step by step and watches alarms'),\n      queryInterval: Duration.seconds(15),\n      totalTimeout: TOTAL_TIMEOUT,\n      logGroup,\n    });\n    this.serviceToken = provider.serviceToken;\n  }\n\n  /**\n   * Adds a statement to the handlers' role, once. Like the shared provider's grants, they must be stable across\n   * updates (prefixes, not names that change) and never reference attributes of resources that use the provider.\n   */\n  public grant(statement: { actions: string[]; resources: string[] }): void {\n    const key = JSON.stringify(Stack.of(this).resolve(statement));\n    if (this.granted.has(key)) return;\n    this.granted.add(key);\n    this.role.addToPrincipalPolicy(new iam.PolicyStatement(statement));\n  }\n}\n\nexport interface TrafficShiftProps {\n  /** Literal function name, for stable IAM grants. */\n  readonly functionName: string;\n  readonly functionArn: string;\n  readonly endpointName: string;\n  readonly revisionId: string;\n  readonly deployment: WebFunctionDeployment;\n  /** The endpoint's other settings: any change makes the shift run, so it can re-check the traffic before CloudFormation writes it. */\n  readonly endpointConfig: unknown;\n}\n\n/**\n * Moves an endpoint's traffic to `revisionId` in steps before CloudFormation updates the endpoint (which must depend on it).\n */\nexport class TrafficShift extends Construct {\n  public readonly resource: CustomResource;\n\n  constructor(scope: Construct, id: string, props: TrafficShiftProps) {\n    super(scope, id);\n    const stack = Stack.of(this);\n    const provider = DeploymentProvider.of(this);\n    const functionArn = stack.formatArn({\n      service: 'lambda', resource: 'web-function', resourceName: props.functionName, arnFormat: ArnFormat.SLASH_RESOURCE_NAME,\n    });\n    // Stable grant (see grantToProvider): every endpoint and revision of the function.\n    provider.grant({\n      actions: ['lambda:GetWebFunctionEndpoint', 'lambda:UpdateWebFunctionEndpoint'],\n      resources: [functionArn, `${functionArn}/endpoint/*`, `${functionArn}/revision/*`],\n    });\n\n    const deployment = props.deployment;\n    const properties: TrafficShiftProperties = {\n      FunctionArn: props.functionArn,\n      EndpointName: props.endpointName,\n      RevisionId: props.revisionId,\n      Steps: deployment._steps.join(','),\n      WaitSeconds: String(deployment._waitSeconds),\n      AlarmArns: deployment._alarms.length > 0 ? deployment._alarms.map((a) => a.alarmArn) : undefined,\n      EndpointConfig: createHash('sha256').update(JSON.stringify(stack.resolve(props.endpointConfig))).digest('hex').slice(0, 16),\n    };\n    this.resource = new CustomResource(this, 'Resource', {\n      serviceToken: provider.serviceToken,\n      resourceType: TRAFFIC_SHIFT_RESOURCE_TYPE,\n      properties: { ...properties },\n      // CloudFormation's maximum; the provider fails the deployment itself after 55 minutes.\n      serviceTimeout: Duration.hours(1),\n    });\n  }\n}\n"]}

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

@@ -0,0 +1,89 @@
+import { Duration } from 'aws-cdk-lib';
+import type * as cloudwatch from 'aws-cdk-lib/aws-cloudwatch';
+/**
+ * Options for a canary deployment.
+ */
+export interface WebFunctionCanaryDeploymentOptions {
+    /**
+     * The share of traffic, in whole percent (1-99), that the new revision gets first.
+     */
+    readonly percent: number;
+    /**
+     * How long the new revision serves `percent` before it gets all traffic (1-45 minutes).
+     * Make it longer than the time your alarms need to fire (period × evaluation periods).
+     */
+    readonly bake: Duration;
+    /**
+     * Alarms that stop the deployment: if one is in ALARM, the endpoint goes back to the previous
+     * revision and the deployment fails, so CloudFormation rolls the stack back.
+     *
+     * They're checked before traffic moves, during the bake, and once the new revision has all traffic.
+     * Use alarms in any region (by ARN), including composite alarms.
+     *
+     * @default - no alarms: traffic moves on a timer
+     */
+    readonly alarms?: cloudwatch.IAlarm[];
+}
+/**
+ * Options for a linear deployment.
+ */
+export interface WebFunctionLinearDeploymentOptions {
+    /**
+     * The share of traffic, in whole percent (5-50), that moves to the new revision at each step.
+     */
+    readonly percent: number;
+    /**
+     * How long each step serves before the next one (at least 1 minute, and at most 45 minutes in total).
+     */
+    readonly interval: Duration;
+    /**
+     * Alarms that stop the deployment: if one is in ALARM, the endpoint goes back to the previous
+     * revision and the deployment fails, so CloudFormation rolls the stack back.
+     *
+     * They're checked before traffic moves, during every step, and once the new revision has all traffic.
+     * Use alarms in any region (by ARN), including composite alarms.
+     *
+     * @default - no alarms: traffic moves on a timer
+     */
+    readonly alarms?: cloudwatch.IAlarm[];
+}
+/**
+ * How an endpoint moves its traffic to a new revision.
+ */
+export declare class WebFunctionDeployment {
+    /**
+     * All traffic moves to the new revision at once, as soon as it's ready (the default).
+     */
+    static allAtOnce(): WebFunctionDeployment;
+    /**
+     * The new revision first gets `percent` of the traffic for `bake`, then all of it.
+     */
+    static canary(options: WebFunctionCanaryDeploymentOptions): WebFunctionDeployment;
+    /**
+     * The new revision gets `percent` more of the traffic every `interval` until it has all of it.
+     */
+    static linear(options: WebFunctionLinearDeploymentOptions): WebFunctionDeployment;
+    /**
+     * The new revision's share of traffic at each step, in percent; the last is 100.
+     *
+     * @internal
+     */
+    readonly _steps: number[];
+    /**
+     * Seconds each step serves before the next.
+     *
+     * @internal
+     */
+    readonly _waitSeconds: number;
+    /** @internal */
+    readonly _alarms: cloudwatch.IAlarm[];
+    /** @internal */
+    readonly _kind: string;
+    private constructor();
+    /**
+     * Whether traffic moves in steps (canary or linear) rather than all at once.
+     *
+     * @internal
+     */
+    get _gradual(): boolean;
+}

package/lib/web-function-deployment.js

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebFunctionDeployment = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const aws_cdk_lib_1 = require("aws-cdk-lib");
+/** Longest total wait of a deployment: the deployment step must finish within CloudFormation's 1-hour custom resource limit. */
+const MAX_TOTAL_WAIT_MINUTES = 45;
+/** Most traffic steps: each one also waits for the endpoint to update in every region. */
+const MAX_STEPS = 20;
+/**
+ * How an endpoint moves its traffic to a new revision.
+ */
+class WebFunctionDeployment {
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "@ashishpandeyone/cdk-lambda-web-function.WebFunctionDeployment", version: "0.1.2" };
+    /**
+     * All traffic moves to the new revision at once, as soon as it's ready (the default).
+     */
+    static allAtOnce() {
+        return new WebFunctionDeployment('allAtOnce', [100], 0, []);
+    }
+    /**
+     * The new revision first gets `percent` of the traffic for `bake`, then all of it.
+     */
+    static canary(options) {
+        const percent = wholePercent('canary', 'percent', options.percent, 1, 99);
+        const bake = minutes('canary', 'bake', options.bake, MAX_TOTAL_WAIT_MINUTES);
+        return new WebFunctionDeployment('canary', [percent, 100], bake.toSeconds(), options.alarms ?? []);
+    }
+    /**
+     * The new revision gets `percent` more of the traffic every `interval` until it has all of it.
+     */
+    static linear(options) {
+        const percent = wholePercent('linear', 'percent', options.percent, 100 / MAX_STEPS, 50);
+        const interval = minutes('linear', 'interval', options.interval, MAX_TOTAL_WAIT_MINUTES);
+        const steps = [];
+        for (let p = percent; p < 100; p += percent)
+            steps.push(p);
+        steps.push(100);
+        const total = interval.toSeconds() * (steps.length - 1);
+        if (total > MAX_TOTAL_WAIT_MINUTES * 60) {
+            throw new Error(`WebFunctionDeployment.linear: ${steps.length - 1} intervals of ${interval.toHumanString()} take ${total / 60} minutes; at most ${MAX_TOTAL_WAIT_MINUTES} are allowed`);
+        }
+        return new WebFunctionDeployment('linear', steps, interval.toSeconds(), options.alarms ?? []);
+    }
+    /**
+     * The new revision's share of traffic at each step, in percent; the last is 100.
+     *
+     * @internal
+     */
+    _steps;
+    /**
+     * Seconds each step serves before the next.
+     *
+     * @internal
+     */
+    _waitSeconds;
+    /** @internal */
+    _alarms;
+    /** @internal */
+    _kind;
+    constructor(kind, steps, waitSeconds, alarms) {
+        this._kind = kind;
+        this._steps = steps;
+        this._waitSeconds = waitSeconds;
+        this._alarms = alarms;
+    }
+    /**
+     * Whether traffic moves in steps (canary or linear) rather than all at once.
+     *
+     * @internal
+     */
+    get _gradual() {
+        return this._steps.length > 1;
+    }
+}
+exports.WebFunctionDeployment = WebFunctionDeployment;
+function wholePercent(kind, name, value, min, max) {
+    if (aws_cdk_lib_1.Token.isUnresolved(value) || !Number.isInteger(value) || value < min || value > max) {
+        throw new Error(`WebFunctionDeployment.${kind}: ${name} must be a whole number from ${Math.ceil(min)} to ${max}, got ${value}`);
+    }
+    return value;
+}
+function minutes(kind, name, value, maxMinutes) {
+    const seconds = value.toSeconds();
+    if (aws_cdk_lib_1.Token.isUnresolved(seconds) || seconds < 60 || seconds > maxMinutes * 60) {
+        throw new Error(`WebFunctionDeployment.${kind}: ${name} must be from 1 to ${maxMinutes} minutes, got ${aws_cdk_lib_1.Token.isUnresolved(seconds) ? 'a token' : value.toHumanString()}`);
+    }
+    return aws_cdk_lib_1.Duration.seconds(seconds);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"web-function-deployment.js","sourceRoot":"","sources":["../src/web-function-deployment.ts"],"names":[],"mappings":"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","sourcesContent":["import { Duration, Token } from 'aws-cdk-lib';\nimport type * as cloudwatch from 'aws-cdk-lib/aws-cloudwatch';\n\n/** Longest total wait of a deployment: the deployment step must finish within CloudFormation's 1-hour custom resource limit. */\nconst MAX_TOTAL_WAIT_MINUTES = 45;\n/** Most traffic steps: each one also waits for the endpoint to update in every region. */\nconst MAX_STEPS = 20;\n\n/**\n * Options for a canary deployment.\n */\nexport interface WebFunctionCanaryDeploymentOptions {\n  /**\n   * The share of traffic, in whole percent (1-99), that the new revision gets first.\n   */\n  readonly percent: number;\n\n  /**\n   * How long the new revision serves `percent` before it gets all traffic (1-45 minutes).\n   * Make it longer than the time your alarms need to fire (period × evaluation periods).\n   */\n  readonly bake: Duration;\n\n  /**\n   * Alarms that stop the deployment: if one is in ALARM, the endpoint goes back to the previous\n   * revision and the deployment fails, so CloudFormation rolls the stack back.\n   *\n   * They're checked before traffic moves, during the bake, and once the new revision has all traffic.\n   * Use alarms in any region (by ARN), including composite alarms.\n   *\n   * @default - no alarms: traffic moves on a timer\n   */\n  readonly alarms?: cloudwatch.IAlarm[];\n}\n\n/**\n * Options for a linear deployment.\n */\nexport interface WebFunctionLinearDeploymentOptions {\n  /**\n   * The share of traffic, in whole percent (5-50), that moves to the new revision at each step.\n   */\n  readonly percent: number;\n\n  /**\n   * How long each step serves before the next one (at least 1 minute, and at most 45 minutes in total).\n   */\n  readonly interval: Duration;\n\n  /**\n   * Alarms that stop the deployment: if one is in ALARM, the endpoint goes back to the previous\n   * revision and the deployment fails, so CloudFormation rolls the stack back.\n   *\n   * They're checked before traffic moves, during every step, and once the new revision has all traffic.\n   * Use alarms in any region (by ARN), including composite alarms.\n   *\n   * @default - no alarms: traffic moves on a timer\n   */\n  readonly alarms?: cloudwatch.IAlarm[];\n}\n\n/**\n * How an endpoint moves its traffic to a new revision.\n */\nexport class WebFunctionDeployment {\n  /**\n   * All traffic moves to the new revision at once, as soon as it's ready (the default).\n   */\n  public static allAtOnce(): WebFunctionDeployment {\n    return new WebFunctionDeployment('allAtOnce', [100], 0, []);\n  }\n\n  /**\n   * The new revision first gets `percent` of the traffic for `bake`, then all of it.\n   */\n  public static canary(options: WebFunctionCanaryDeploymentOptions): WebFunctionDeployment {\n    const percent = wholePercent('canary', 'percent', options.percent, 1, 99);\n    const bake = minutes('canary', 'bake', options.bake, MAX_TOTAL_WAIT_MINUTES);\n    return new WebFunctionDeployment('canary', [percent, 100], bake.toSeconds(), options.alarms ?? []);\n  }\n\n  /**\n   * The new revision gets `percent` more of the traffic every `interval` until it has all of it.\n   */\n  public static linear(options: WebFunctionLinearDeploymentOptions): WebFunctionDeployment {\n    const percent = wholePercent('linear', 'percent', options.percent, 100 / MAX_STEPS, 50);\n    const interval = minutes('linear', 'interval', options.interval, MAX_TOTAL_WAIT_MINUTES);\n    const steps: number[] = [];\n    for (let p = percent; p < 100; p += percent) steps.push(p);\n    steps.push(100);\n    const total = interval.toSeconds() * (steps.length - 1);\n    if (total > MAX_TOTAL_WAIT_MINUTES * 60) {\n      throw new Error(`WebFunctionDeployment.linear: ${steps.length - 1} intervals of ${interval.toHumanString()} take ${total / 60} minutes; at most ${MAX_TOTAL_WAIT_MINUTES} are allowed`);\n    }\n    return new WebFunctionDeployment('linear', steps, interval.toSeconds(), options.alarms ?? []);\n  }\n\n  /**\n   * The new revision's share of traffic at each step, in percent; the last is 100.\n   *\n   * @internal\n   */\n  public readonly _steps: number[];\n\n  /**\n   * Seconds each step serves before the next.\n   *\n   * @internal\n   */\n  public readonly _waitSeconds: number;\n\n  /** @internal */\n  public readonly _alarms: cloudwatch.IAlarm[];\n\n  /** @internal */\n  public readonly _kind: string;\n\n  private constructor(kind: string, steps: number[], waitSeconds: number, alarms: cloudwatch.IAlarm[]) {\n    this._kind = kind;\n    this._steps = steps;\n    this._waitSeconds = waitSeconds;\n    this._alarms = alarms;\n  }\n\n  /**\n   * Whether traffic moves in steps (canary or linear) rather than all at once.\n   *\n   * @internal\n   */\n  public get _gradual(): boolean {\n    return this._steps.length > 1;\n  }\n}\n\nfunction wholePercent(kind: string, name: string, value: number, min: number, max: number): number {\n  if (Token.isUnresolved(value) || !Number.isInteger(value) || value < min || value > max) {\n    throw new Error(`WebFunctionDeployment.${kind}: ${name} must be a whole number from ${Math.ceil(min)} to ${max}, got ${value}`);\n  }\n  return value;\n}\n\nfunction minutes(kind: string, name: string, value: Duration, maxMinutes: number): Duration {\n  const seconds = value.toSeconds();\n  if (Token.isUnresolved(seconds) || seconds < 60 || seconds > maxMinutes * 60) {\n    throw new Error(`WebFunctionDeployment.${kind}: ${name} must be from 1 to ${maxMinutes} minutes, got ${Token.isUnresolved(seconds) ? 'a token' : value.toHumanString()}`);\n  }\n  return Duration.seconds(seconds);\n}\n"]}