@sitblueprint/website-construct 0.1.5 → 0.1.6

package/lambda/index.ts

@@ -0,0 +1,335 @@
+type APIGatewayProxyEvent = {
+  body: string | null;
+  path: string;
+};
+
+type APIGatewayProxyResult = {
+  statusCode: number;
+  headers: Record<string, string>;
+  body: string;
+};
+
+const AWS = require("aws-sdk");
+
+type SlotDefinition = {
+  slotId: number;
+  bucketName: string;
+  previewUrl: string;
+};
+
+type SlotLease = {
+  slotId: string;
+  repoPrKey: string;
+  bucketName: string;
+  previewUrl: string;
+  lastUsedAt?: number;
+  leaseExpiresAt?: number;
+  commitSha?: string;
+};
+
+const ddb = new AWS.DynamoDB.DocumentClient();
+const tableName = process.env.TABLE_NAME ?? "";
+const slotDefinitions: SlotDefinition[] = JSON.parse(
+  process.env.SLOT_DEFINITIONS ?? "[]",
+);
+const maxLeaseMs = Number(process.env.MAX_LEASE_MS ?? "86400000");
+
+const ok = (body: Record<string, unknown>): APIGatewayProxyResult => ({
+  statusCode: 200,
+  headers: { "content-type": "application/json" },
+  body: JSON.stringify(body),
+});
+
+const badRequest = (message: string): APIGatewayProxyResult => ({
+  statusCode: 400,
+  headers: { "content-type": "application/json" },
+  body: JSON.stringify({ error: message }),
+});
+
+const conflict = (message: string): APIGatewayProxyResult => ({
+  statusCode: 409,
+  headers: { "content-type": "application/json" },
+  body: JSON.stringify({ error: message }),
+});
+
+const toRepoPrKey = (repo: string, prNumber: number): string =>
+  `${repo}#${prNumber}`;
+
+const nowMs = (): number => Date.now();
+const nowEpochSeconds = (): number => Math.floor(Date.now() / 1000);
+
+const isConditionalCheckFailure = (error: unknown): boolean => {
+  if (!(error instanceof Error)) return false;
+  return error.name === "ConditionalCheckFailedException";
+};
+
+const parseBody = (event: APIGatewayProxyEvent): Record<string, unknown> => {
+  if (!event.body) return {};
+  return JSON.parse(event.body) as Record<string, unknown>;
+};
+
+const getClaimBody = (body: Record<string, unknown>) => {
+  const repo = typeof body.repo === "string" ? body.repo : "";
+  const prNumber = Number(body.prNumber);
+  const commitSha = typeof body.commitSha === "string" ? body.commitSha : "";
+  return { repo, prNumber, commitSha };
+};
+
+const getReleaseBody = (body: Record<string, unknown>) => {
+  const repo = typeof body.repo === "string" ? body.repo : "";
+  const prNumber = Number(body.prNumber);
+  return { repo, prNumber };
+};
+
+const queryLeaseByRepoPr = async (
+  repoPrKey: string,
+): Promise<SlotLease | null> => {
+  const result = await ddb
+    .query({
+      TableName: tableName,
+      IndexName: "RepoPrKeyIndex",
+      KeyConditionExpression: "repoPrKey = :repoPrKey",
+      ExpressionAttributeValues: {
+        ":repoPrKey": repoPrKey,
+      },
+      Limit: 1,
+    })
+    .promise();
+
+  if (!result.Items || result.Items.length === 0) {
+    return null;
+  }
+
+  return result.Items[0] as SlotLease;
+};
+
+const loadSlots = async (): Promise<
+  Array<SlotDefinition & { lease: SlotLease | null }>
+> => {
+  if (slotDefinitions.length === 0) {
+    return [];
+  }
+
+  const result = await ddb
+    .batchGet({
+      RequestItems: {
+        [tableName]: {
+          Keys: slotDefinitions.map((slot) => ({
+            slotId: String(slot.slotId),
+          })),
+        },
+      },
+    })
+    .promise();
+
+  const tableItems = (result.Responses?.[tableName] ?? []) as SlotLease[];
+  const bySlotId = new Map<string, SlotLease>();
+  tableItems.forEach((item) => bySlotId.set(item.slotId, item));
+
+  return slotDefinitions.map((slot) => ({
+    ...slot,
+    lease: bySlotId.get(String(slot.slotId)) ?? null,
+  }));
+};
+
+const chooseSlot = (
+  slots: Array<SlotDefinition & { lease: SlotLease | null }>,
+  repoPrKey: string,
+  now: number,
+): {
+  slot: SlotDefinition & { lease: SlotLease | null };
+  expectedLastUsedAt: number | null;
+} => {
+  const existing = slots.find((slot) => slot.lease?.repoPrKey === repoPrKey);
+  if (existing) {
+    return {
+      slot: existing,
+      expectedLastUsedAt: Number(existing.lease?.lastUsedAt ?? 0),
+    };
+  }
+
+  const available = slots
+    .filter(
+      (slot) => !slot.lease || Number(slot.lease.leaseExpiresAt ?? 0) < now,
+    )
+    .sort(
+      (a, b) =>
+        Number(a.lease?.lastUsedAt ?? 0) - Number(b.lease?.lastUsedAt ?? 0),
+    );
+  if (available.length > 0) {
+    return {
+      slot: available[0],
+      expectedLastUsedAt: available[0].lease
+        ? Number(available[0].lease.lastUsedAt ?? 0)
+        : null,
+    };
+  }
+
+  const lru = [...slots].sort(
+    (a, b) =>
+      Number(a.lease?.lastUsedAt ?? 0) - Number(b.lease?.lastUsedAt ?? 0),
+  )[0];
+  return {
+    slot: lru,
+    expectedLastUsedAt: Number(lru.lease?.lastUsedAt ?? 0),
+  };
+};
+
+const claim = async (
+  repo: string,
+  prNumber: number,
+  commitSha: string,
+): Promise<APIGatewayProxyResult> => {
+  if (!repo || !Number.isInteger(prNumber)) {
+    return badRequest("repo and integer prNumber are required");
+  }
+
+  const repoPrKey = toRepoPrKey(repo, prNumber);
+  for (let attempts = 0; attempts < 5; attempts += 1) {
+    const now = nowMs();
+    const slots = await loadSlots();
+    if (slots.length === 0) {
+      return badRequest("No preview slots configured");
+    }
+
+    const selection = chooseSlot(slots, repoPrKey, now);
+    const slot = selection.slot;
+
+    const expressionAttributeValues: Record<string, unknown> = {
+      ":repo": repo,
+      ":prNumber": prNumber,
+      ":repoPrKey": repoPrKey,
+      ":commitSha": commitSha,
+      ":now": now,
+      ":expiresAt": now + maxLeaseMs,
+      ":ttlEpochSeconds": nowEpochSeconds() + Math.floor(maxLeaseMs / 1000),
+      ":bucketName": slot.bucketName,
+      ":previewUrl": slot.previewUrl,
+    };
+
+    let conditionExpression = "attribute_not_exists(slotId)";
+    if (selection.expectedLastUsedAt !== null) {
+      conditionExpression =
+        "lastUsedAt = :expectedLastUsedAt OR repoPrKey = :repoPrKey";
+      expressionAttributeValues[":expectedLastUsedAt"] =
+        selection.expectedLastUsedAt;
+    }
+
+    try {
+      await ddb
+        .update({
+          TableName: tableName,
+          Key: { slotId: String(slot.slotId) },
+          UpdateExpression:
+            "SET repo = :repo, prNumber = :prNumber, repoPrKey = :repoPrKey, commitSha = :commitSha, bucketName = :bucketName, previewUrl = :previewUrl, leasedAt = if_not_exists(leasedAt, :now), lastUsedAt = :now, leaseExpiresAt = :expiresAt, ttlEpochSeconds = :ttlEpochSeconds",
+          ConditionExpression: conditionExpression,
+          ExpressionAttributeValues: expressionAttributeValues,
+        })
+        .promise();
+
+      return ok({
+        slotId: slot.slotId,
+        bucketName: slot.bucketName,
+        previewUrl: slot.previewUrl,
+      });
+    } catch (error) {
+      if (!isConditionalCheckFailure(error)) {
+        throw error;
+      }
+    }
+  }
+
+  return conflict("Failed to claim preview slot due to concurrent updates");
+};
+
+const heartbeat = async (
+  repo: string,
+  prNumber: number,
+  commitSha: string,
+): Promise<APIGatewayProxyResult> => {
+  if (!repo || !Number.isInteger(prNumber)) {
+    return badRequest("repo and integer prNumber are required");
+  }
+
+  const repoPrKey = toRepoPrKey(repo, prNumber);
+  const existing = await queryLeaseByRepoPr(repoPrKey);
+  if (!existing) {
+    return badRequest("No active lease found for this pull request");
+  }
+
+  const now = nowMs();
+  await ddb
+    .update({
+      TableName: tableName,
+      Key: { slotId: existing.slotId },
+      UpdateExpression:
+        "SET commitSha = :commitSha, lastUsedAt = :now, leaseExpiresAt = :expiresAt, ttlEpochSeconds = :ttlEpochSeconds",
+      ConditionExpression: "repoPrKey = :repoPrKey",
+      ExpressionAttributeValues: {
+        ":repoPrKey": repoPrKey,
+        ":commitSha": commitSha || existing.commitSha || "",
+        ":now": now,
+        ":expiresAt": now + maxLeaseMs,
+        ":ttlEpochSeconds": nowEpochSeconds() + Math.floor(maxLeaseMs / 1000),
+      },
+    })
+    .promise();
+
+  return ok({
+    slotId: existing.slotId,
+    bucketName: existing.bucketName,
+    previewUrl: existing.previewUrl,
+  });
+};
+
+const release = async (
+  repo: string,
+  prNumber: number,
+): Promise<APIGatewayProxyResult> => {
+  if (!repo || !Number.isInteger(prNumber)) {
+    return badRequest("repo and integer prNumber are required");
+  }
+
+  const repoPrKey = toRepoPrKey(repo, prNumber);
+  const existing = await queryLeaseByRepoPr(repoPrKey);
+  if (!existing) {
+    return ok({ released: false });
+  }
+
+  await ddb
+    .delete({
+      TableName: tableName,
+      Key: { slotId: existing.slotId },
+      ConditionExpression: "repoPrKey = :repoPrKey",
+      ExpressionAttributeValues: {
+        ":repoPrKey": repoPrKey,
+      },
+    })
+    .promise();
+
+  return ok({ released: true, slotId: existing.slotId });
+};
+
+export const handler = async (
+  event: APIGatewayProxyEvent,
+): Promise<APIGatewayProxyResult> => {
+  const body = parseBody(event);
+  const path = event.path ?? "";
+
+  if (path.endsWith("/claim")) {
+    const { repo, prNumber, commitSha } = getClaimBody(body);
+    return claim(repo, prNumber, commitSha);
+  }
+
+  if (path.endsWith("/heartbeat")) {
+    const { repo, prNumber, commitSha } = getClaimBody(body);
+    return heartbeat(repo, prNumber, commitSha);
+  }
+
+  if (path.endsWith("/release")) {
+    const { repo, prNumber } = getReleaseBody(body);
+    return release(repo, prNumber);
+  }
+
+  return badRequest("Unsupported route");
+};

package/lib/index.d.ts

@@ -1,6 +1,9 @@
 import { Construct } from "constructs";
 import * as s3 from "aws-cdk-lib/aws-s3";
 import * as cloudfont from "aws-cdk-lib/aws-cloudfront";
+import * as iam from "aws-cdk-lib/aws-iam";
+import * as dynamodb from "aws-cdk-lib/aws-dynamodb";
+import * as apigateway from "aws-cdk-lib/aws-apigateway";
 export interface DomainConfig {
     /** The root domain name (e.g., example.com).
      * There must be an associated hosted zone in Route 53 for this domain.
@@ -27,11 +30,47 @@ export interface WebsiteProps {
     domainConfig?: DomainConfig;
     /** Optional path to a custom 404 page. If not specified, the error file will be used. */
     notFoundResponsePagePath?: string;
+    /** Optional configuration for pull request preview environments. */
+    previewConfig?: PreviewConfig;
+}
+export interface PreviewConfig {
+    /** Prefix used to name preview buckets. Buckets are created as `${prefix}-0`, `${prefix}-1`, ... */
+    bucketPrefix: string;
+    /** Number of preview buckets to create.
+     * @default 2
+     */
+    bucketCount?: number;
+    /** If true, creates one CloudFront distribution per preview bucket.
+     * @default true
+     */
+    createDistributions?: boolean;
+    /** Maximum lease lifetime in hours before a slot is considered expired.
+     * @default 24
+     */
+    maxLeaseHours?: number;
+}
+export interface PreviewEnvironmentProps extends PreviewConfig {
+    /** Index document for preview buckets. */
+    indexFile: string;
+    /** Error document for preview buckets. */
+    errorFile: string;
 }
 export declare class Website extends Construct {
     readonly bucket: s3.Bucket;
     readonly distribution: cloudfont.Distribution;
+    readonly previewEnvironment?: PreviewEnvironment;
     constructor(scope: Construct, id: string, props: WebsiteProps);
     private _getFullDomainName;
     private _getCertificate;
 }
+export declare class PreviewEnvironment extends Construct {
+    readonly buckets: s3.Bucket[];
+    readonly distributions: cloudfont.Distribution[];
+    readonly leaseTable: dynamodb.Table;
+    readonly api: apigateway.RestApi;
+    readonly claimEndpoint: string;
+    readonly heartbeatEndpoint: string;
+    readonly releaseEndpoint: string;
+    constructor(scope: Construct, id: string, props: PreviewEnvironmentProps);
+    grantDeploymentAccess(grantee: iam.IGrantable): void;
+}

package/lib/index.js

@@ -33,7 +33,7 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Website = void 0;
+exports.PreviewEnvironment = exports.Website = void 0;
 const constructs_1 = require("constructs");
 const s3 = __importStar(require("aws-cdk-lib/aws-s3"));
 const cloudfont = __importStar(require("aws-cdk-lib/aws-cloudfront"));
@@ -42,9 +42,14 @@ const certificatemanager = __importStar(require("aws-cdk-lib/aws-certificatemana
 const cdk = __importStar(require("aws-cdk-lib"));
 const iam = __importStar(require("aws-cdk-lib/aws-iam"));
 const route53 = __importStar(require("aws-cdk-lib/aws-route53"));
+const dynamodb = __importStar(require("aws-cdk-lib/aws-dynamodb"));
+const lambda = __importStar(require("aws-cdk-lib/aws-lambda"));
+const apigateway = __importStar(require("aws-cdk-lib/aws-apigateway"));
+const path = __importStar(require("path"));
 class Website extends constructs_1.Construct {
     bucket;
     distribution;
+    previewEnvironment;
     constructor(scope, id, props) {
         super(scope, id);
         this.bucket = new s3.Bucket(this, props.bucketName, {
@@ -126,6 +131,13 @@ class Website extends constructs_1.Construct {
                 description: "Website URL",
             });
         }
+        if (props.previewConfig) {
+            this.previewEnvironment = new PreviewEnvironment(this, "PreviewEnvironment", {
+                ...props.previewConfig,
+                indexFile: props.indexFile,
+                errorFile: props.errorFile,
+            });
+        }
     }
     _getFullDomainName(domainConfig) {
         return domainConfig.subdomainName
@@ -137,4 +149,129 @@ class Website extends constructs_1.Construct {
     }
 }
 exports.Website = Website;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["index.ts"],"names":[],"mappings":"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","sourcesContent":["import { Construct } from \"constructs\";\nimport * as s3 from \"aws-cdk-lib/aws-s3\";\nimport * as cloudfont from \"aws-cdk-lib/aws-cloudfront\";\nimport * as origins from \"aws-cdk-lib/aws-cloudfront-origins\";\nimport * as certificatemanager from \"aws-cdk-lib/aws-certificatemanager\";\nimport * as cdk from \"aws-cdk-lib\";\nimport * as iam from \"aws-cdk-lib/aws-iam\";\nimport * as route53 from \"aws-cdk-lib/aws-route53\";\n\nexport interface DomainConfig {\n  /** The root domain name (e.g., example.com).\n   * There must be an associated hosted zone in Route 53 for this domain.\n   */\n  domainName: string;\n  /** The subdomain name */\n  subdomainName: string;\n  /** The ARN of the SSL certificate to use for the domain. */\n  certificateArn: string;\n  /**\n   * If true, creates an additional Route 53 record for the root domain pointing to the CloudFront distribution.\n   * @default false\n   */\n  includeRootDomain?: boolean;\n}\n\nexport interface WebsiteProps {\n  /** The name of the S3 bucket that will host the website content. */\n  bucketName: string;\n\n  /** The path to the index document that will be served as the default page. */\n  indexFile: string;\n\n  /** The path to the error document that will be served when an error occurs. */\n  errorFile: string;\n\n  /** Optional configuration for custom domain setup. */\n  domainConfig?: DomainConfig;\n\n  /** Optional path to a custom 404 page. If not specified, the error file will be used. */\n  notFoundResponsePagePath?: string;\n}\n\nexport class Website extends Construct {\n  public readonly bucket: s3.Bucket;\n  public readonly distribution: cloudfont.Distribution;\n\n  constructor(scope: Construct, id: string, props: WebsiteProps) {\n    super(scope, id);\n    this.bucket = new s3.Bucket(this, props.bucketName, {\n      websiteIndexDocument: props.indexFile,\n      websiteErrorDocument: props.errorFile,\n      publicReadAccess: true,\n      removalPolicy: cdk.RemovalPolicy.DESTROY,\n      blockPublicAccess: s3.BlockPublicAccess.BLOCK_ACLS_ONLY,\n      accessControl: s3.BucketAccessControl.BUCKET_OWNER_FULL_CONTROL,\n      encryption: s3.BucketEncryption.S3_MANAGED,\n    });\n    const oai = new cloudfont.OriginAccessIdentity(\n      this,\n      `${props.bucketName}-OAI`,\n    );\n    this.bucket.addToResourcePolicy(\n      new iam.PolicyStatement({\n        actions: [\"s3:GetObject\"],\n        resources: [this.bucket.arnForObjects(\"*\")],\n        principals: [\n          new iam.CanonicalUserPrincipal(\n            oai.cloudFrontOriginAccessIdentityS3CanonicalUserId,\n          ),\n        ],\n      }),\n    );\n    const domainNames: string[] = [];\n    if (props.domainConfig) {\n      domainNames.push(this._getFullDomainName(props.domainConfig));\n      if (\n        props.domainConfig.includeRootDomain &&\n        props.domainConfig.subdomainName\n      ) {\n        domainNames.push(props.domainConfig.domainName);\n      }\n    }\n\n    this.distribution = new cloudfont.Distribution(\n      this,\n      `${props.bucketName}-distribution`,\n      {\n        defaultBehavior: {\n          origin: new origins.S3StaticWebsiteOrigin(this.bucket),\n          viewerProtocolPolicy:\n            cloudfont.ViewerProtocolPolicy.REDIRECT_TO_HTTPS,\n        },\n        errorResponses: [\n          {\n            httpStatus: 404,\n            responseHttpStatus: 404,\n            responsePagePath: props.notFoundResponsePagePath || `/404.html`,\n            ttl: cdk.Duration.minutes(30),\n          },\n        ],\n        priceClass: cloudfont.PriceClass.PRICE_CLASS_100,\n        ...(props.domainConfig\n          ? {\n              domainNames: domainNames,\n              certificate: this._getCertificate(\n                props.domainConfig.certificateArn,\n              ),\n            }\n          : {}),\n      },\n    );\n\n    if (props.domainConfig) {\n      const hostedZone = route53.HostedZone.fromLookup(this, \"HostedZone\", {\n        domainName: props.domainConfig.domainName,\n      });\n      const domainARecord = new route53.ARecord(this, \"DomainARecord\", {\n        zone: hostedZone,\n        recordName: this._getFullDomainName(props.domainConfig),\n        target: cdk.aws_route53.RecordTarget.fromAlias(\n          new cdk.aws_route53_targets.CloudFrontTarget(this.distribution),\n        ),\n      });\n      domainARecord.node.addDependency(this.distribution);\n\n      if (\n        props.domainConfig.includeRootDomain &&\n        props.domainConfig.subdomainName\n      ) {\n        new route53.ARecord(this, \"RootDomainARecord\", {\n          zone: hostedZone,\n          recordName: props.domainConfig.domainName,\n          target: cdk.aws_route53.RecordTarget.fromAlias(\n            new cdk.aws_route53_targets.CloudFrontTarget(this.distribution),\n          ),\n        }).node.addDependency(this.distribution);\n      }\n    }\n\n    new cdk.CfnOutput(this, \"cloudfront-website-url\", {\n      value: this.distribution.distributionDomainName,\n      description: \"CloudFront Distribution Domain Name\",\n    });\n\n    new cdk.CfnOutput(this, \"s3-website-url\", {\n      value: this.bucket.bucketWebsiteUrl,\n      description: \"S3 Bucket Website URL\",\n    });\n\n    if (props.domainConfig) {\n      new cdk.CfnOutput(this, \"website-url\", {\n        value: this.distribution.domainName,\n        description: \"Website URL\",\n      });\n    }\n  }\n\n  private _getFullDomainName(domainConfig: DomainConfig): string {\n    return domainConfig.subdomainName\n      ? `${domainConfig.subdomainName}.${domainConfig.domainName}`\n      : domainConfig.domainName;\n  }\n\n  private _getCertificate(arn: string): certificatemanager.ICertificate {\n    return certificatemanager.Certificate.fromCertificateArn(\n      this,\n      `website-cert`,\n      arn,\n    );\n  }\n}\n"]}
+class PreviewEnvironment extends constructs_1.Construct {
+    buckets;
+    distributions;
+    leaseTable;
+    api;
+    claimEndpoint;
+    heartbeatEndpoint;
+    releaseEndpoint;
+    constructor(scope, id, props) {
+        super(scope, id);
+        const bucketCount = props.bucketCount ?? 2;
+        if (bucketCount < 1) {
+            throw new Error("bucketCount must be greater than or equal to 1");
+        }
+        const indexFile = props.indexFile;
+        const errorFile = props.errorFile;
+        const createDistributions = props.createDistributions ?? true;
+        const maxLeaseHours = props.maxLeaseHours ?? 24;
+        const maxLeaseMs = cdk.Duration.hours(maxLeaseHours).toMilliseconds();
+        this.buckets = Array.from({ length: bucketCount }, (_, slotId) => {
+            const bucketName = `${props.bucketPrefix}-${slotId}`;
+            return new s3.Bucket(this, `PreviewBucket${slotId}`, {
+                bucketName,
+                websiteIndexDocument: indexFile,
+                websiteErrorDocument: errorFile,
+                publicReadAccess: true,
+                removalPolicy: cdk.RemovalPolicy.DESTROY,
+                autoDeleteObjects: true,
+                blockPublicAccess: s3.BlockPublicAccess.BLOCK_ACLS_ONLY,
+                accessControl: s3.BucketAccessControl.BUCKET_OWNER_FULL_CONTROL,
+                encryption: s3.BucketEncryption.S3_MANAGED,
+            });
+        });
+        this.distributions = createDistributions
+            ? this.buckets.map((bucket, slotId) => {
+                const oai = new cloudfont.OriginAccessIdentity(this, `PreviewOAI${slotId}`);
+                bucket.addToResourcePolicy(new iam.PolicyStatement({
+                    actions: ["s3:GetObject"],
+                    resources: [bucket.arnForObjects("*")],
+                    principals: [
+                        new iam.CanonicalUserPrincipal(oai.cloudFrontOriginAccessIdentityS3CanonicalUserId),
+                    ],
+                }));
+                return new cloudfont.Distribution(this, `PreviewDistribution${slotId}`, {
+                    defaultBehavior: {
+                        origin: new origins.S3StaticWebsiteOrigin(bucket),
+                        viewerProtocolPolicy: cloudfont.ViewerProtocolPolicy.REDIRECT_TO_HTTPS,
+                    },
+                    priceClass: cloudfont.PriceClass.PRICE_CLASS_100,
+                });
+            })
+            : [];
+        this.leaseTable = new dynamodb.Table(this, "PreviewLeases", {
+            partitionKey: {
+                name: "slotId",
+                type: dynamodb.AttributeType.STRING,
+            },
+            billingMode: dynamodb.BillingMode.PAY_PER_REQUEST,
+            removalPolicy: cdk.RemovalPolicy.DESTROY,
+            timeToLiveAttribute: "ttlEpochSeconds",
+        });
+        this.leaseTable.addGlobalSecondaryIndex({
+            indexName: "RepoPrKeyIndex",
+            partitionKey: {
+                name: "repoPrKey",
+                type: dynamodb.AttributeType.STRING,
+            },
+            projectionType: dynamodb.ProjectionType.ALL,
+        });
+        const slotDefinitions = this.buckets.map((bucket, slotId) => ({
+            slotId,
+            bucketName: bucket.bucketName,
+            previewUrl: this.distributions[slotId]
+                ? `https://${this.distributions[slotId].distributionDomainName}`
+                : bucket.bucketWebsiteUrl,
+        }));
+        const leaseApiHandler = new lambda.Function(this, "PreviewLeaseApiHandler", {
+            runtime: lambda.Runtime.NODEJS_20_X,
+            handler: "index.handler",
+            timeout: cdk.Duration.seconds(15),
+            code: lambda.Code.fromAsset(path.join(__dirname, "..", "lambda")),
+            environment: {
+                TABLE_NAME: this.leaseTable.tableName,
+                SLOT_DEFINITIONS: JSON.stringify(slotDefinitions),
+                MAX_LEASE_MS: String(maxLeaseMs),
+            },
+        });
+        this.leaseTable.grantReadWriteData(leaseApiHandler);
+        this.api = new apigateway.RestApi(this, "PreviewLeaseApi", {
+            restApiName: `${cdk.Names.uniqueId(this)}-preview-lease-api`,
+            description: "API for claiming/releasing preview slots",
+        });
+        const claimResource = this.api.root.addResource("claim");
+        claimResource.addMethod("POST", new apigateway.LambdaIntegration(leaseApiHandler));
+        const heartbeatResource = this.api.root.addResource("heartbeat");
+        heartbeatResource.addMethod("POST", new apigateway.LambdaIntegration(leaseApiHandler));
+        const releaseResource = this.api.root.addResource("release");
+        releaseResource.addMethod("POST", new apigateway.LambdaIntegration(leaseApiHandler));
+        this.claimEndpoint = `${this.api.url}claim`;
+        this.heartbeatEndpoint = `${this.api.url}heartbeat`;
+        this.releaseEndpoint = `${this.api.url}release`;
+        new cdk.CfnOutput(this, "preview-claim-endpoint", {
+            value: this.claimEndpoint,
+            description: "POST endpoint used to claim a preview slot",
+        });
+        new cdk.CfnOutput(this, "preview-heartbeat-endpoint", {
+            value: this.heartbeatEndpoint,
+            description: "POST endpoint used to refresh a preview slot lease",
+        });
+        new cdk.CfnOutput(this, "preview-release-endpoint", {
+            value: this.releaseEndpoint,
+            description: "POST endpoint used to release a preview slot",
+        });
+    }
+    grantDeploymentAccess(grantee) {
+        this.buckets.forEach((bucket) => bucket.grantReadWrite(grantee));
+        this.distributions.forEach((distribution) => {
+            grantee.grantPrincipal.addToPrincipalPolicy(new iam.PolicyStatement({
+                actions: ["cloudfront:CreateInvalidation"],
+                resources: [distribution.distributionArn],
+            }));
+        });
+    }
+}
+exports.PreviewEnvironment = PreviewEnvironment;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["index.ts"],"names":[],"mappings":"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","sourcesContent":["import { Construct } from \"constructs\";\nimport * as s3 from \"aws-cdk-lib/aws-s3\";\nimport * as cloudfont from \"aws-cdk-lib/aws-cloudfront\";\nimport * as origins from \"aws-cdk-lib/aws-cloudfront-origins\";\nimport * as certificatemanager from \"aws-cdk-lib/aws-certificatemanager\";\nimport * as cdk from \"aws-cdk-lib\";\nimport * as iam from \"aws-cdk-lib/aws-iam\";\nimport * as route53 from \"aws-cdk-lib/aws-route53\";\nimport * as dynamodb from \"aws-cdk-lib/aws-dynamodb\";\nimport * as lambda from \"aws-cdk-lib/aws-lambda\";\nimport * as apigateway from \"aws-cdk-lib/aws-apigateway\";\nimport * as path from \"path\";\n\nexport interface DomainConfig {\n  /** The root domain name (e.g., example.com).\n   * There must be an associated hosted zone in Route 53 for this domain.\n   */\n  domainName: string;\n  /** The subdomain name */\n  subdomainName: string;\n  /** The ARN of the SSL certificate to use for the domain. */\n  certificateArn: string;\n  /**\n   * If true, creates an additional Route 53 record for the root domain pointing to the CloudFront distribution.\n   * @default false\n   */\n  includeRootDomain?: boolean;\n}\n\nexport interface WebsiteProps {\n  /** The name of the S3 bucket that will host the website content. */\n  bucketName: string;\n\n  /** The path to the index document that will be served as the default page. */\n  indexFile: string;\n\n  /** The path to the error document that will be served when an error occurs. */\n  errorFile: string;\n\n  /** Optional configuration for custom domain setup. */\n  domainConfig?: DomainConfig;\n\n  /** Optional path to a custom 404 page. If not specified, the error file will be used. */\n  notFoundResponsePagePath?: string;\n\n  /** Optional configuration for pull request preview environments. */\n  previewConfig?: PreviewConfig;\n}\n\nexport interface PreviewConfig {\n  /** Prefix used to name preview buckets. Buckets are created as `${prefix}-0`, `${prefix}-1`, ... */\n  bucketPrefix: string;\n\n  /** Number of preview buckets to create.\n   * @default 2\n   */\n  bucketCount?: number;\n\n  /** If true, creates one CloudFront distribution per preview bucket.\n   * @default true\n   */\n  createDistributions?: boolean;\n\n  /** Maximum lease lifetime in hours before a slot is considered expired.\n   * @default 24\n   */\n  maxLeaseHours?: number;\n}\n\nexport interface PreviewEnvironmentProps extends PreviewConfig {\n  /** Index document for preview buckets. */\n  indexFile: string;\n\n  /** Error document for preview buckets. */\n  errorFile: string;\n}\n\nexport class Website extends Construct {\n  public readonly bucket: s3.Bucket;\n  public readonly distribution: cloudfont.Distribution;\n  public readonly previewEnvironment?: PreviewEnvironment;\n\n  constructor(scope: Construct, id: string, props: WebsiteProps) {\n    super(scope, id);\n    this.bucket = new s3.Bucket(this, props.bucketName, {\n      websiteIndexDocument: props.indexFile,\n      websiteErrorDocument: props.errorFile,\n      publicReadAccess: true,\n      removalPolicy: cdk.RemovalPolicy.DESTROY,\n      blockPublicAccess: s3.BlockPublicAccess.BLOCK_ACLS_ONLY,\n      accessControl: s3.BucketAccessControl.BUCKET_OWNER_FULL_CONTROL,\n      encryption: s3.BucketEncryption.S3_MANAGED,\n    });\n    const oai = new cloudfont.OriginAccessIdentity(\n      this,\n      `${props.bucketName}-OAI`,\n    );\n    this.bucket.addToResourcePolicy(\n      new iam.PolicyStatement({\n        actions: [\"s3:GetObject\"],\n        resources: [this.bucket.arnForObjects(\"*\")],\n        principals: [\n          new iam.CanonicalUserPrincipal(\n            oai.cloudFrontOriginAccessIdentityS3CanonicalUserId,\n          ),\n        ],\n      }),\n    );\n    const domainNames: string[] = [];\n    if (props.domainConfig) {\n      domainNames.push(this._getFullDomainName(props.domainConfig));\n      if (\n        props.domainConfig.includeRootDomain &&\n        props.domainConfig.subdomainName\n      ) {\n        domainNames.push(props.domainConfig.domainName);\n      }\n    }\n\n    this.distribution = new cloudfont.Distribution(\n      this,\n      `${props.bucketName}-distribution`,\n      {\n        defaultBehavior: {\n          origin: new origins.S3StaticWebsiteOrigin(this.bucket),\n          viewerProtocolPolicy:\n            cloudfont.ViewerProtocolPolicy.REDIRECT_TO_HTTPS,\n        },\n        errorResponses: [\n          {\n            httpStatus: 404,\n            responseHttpStatus: 404,\n            responsePagePath: props.notFoundResponsePagePath || `/404.html`,\n            ttl: cdk.Duration.minutes(30),\n          },\n        ],\n        priceClass: cloudfont.PriceClass.PRICE_CLASS_100,\n        ...(props.domainConfig\n          ? {\n              domainNames: domainNames,\n              certificate: this._getCertificate(\n                props.domainConfig.certificateArn,\n              ),\n            }\n          : {}),\n      },\n    );\n\n    if (props.domainConfig) {\n      const hostedZone = route53.HostedZone.fromLookup(this, \"HostedZone\", {\n        domainName: props.domainConfig.domainName,\n      });\n      const domainARecord = new route53.ARecord(this, \"DomainARecord\", {\n        zone: hostedZone,\n        recordName: this._getFullDomainName(props.domainConfig),\n        target: cdk.aws_route53.RecordTarget.fromAlias(\n          new cdk.aws_route53_targets.CloudFrontTarget(this.distribution),\n        ),\n      });\n      domainARecord.node.addDependency(this.distribution);\n\n      if (\n        props.domainConfig.includeRootDomain &&\n        props.domainConfig.subdomainName\n      ) {\n        new route53.ARecord(this, \"RootDomainARecord\", {\n          zone: hostedZone,\n          recordName: props.domainConfig.domainName,\n          target: cdk.aws_route53.RecordTarget.fromAlias(\n            new cdk.aws_route53_targets.CloudFrontTarget(this.distribution),\n          ),\n        }).node.addDependency(this.distribution);\n      }\n    }\n\n    new cdk.CfnOutput(this, \"cloudfront-website-url\", {\n      value: this.distribution.distributionDomainName,\n      description: \"CloudFront Distribution Domain Name\",\n    });\n\n    new cdk.CfnOutput(this, \"s3-website-url\", {\n      value: this.bucket.bucketWebsiteUrl,\n      description: \"S3 Bucket Website URL\",\n    });\n\n    if (props.domainConfig) {\n      new cdk.CfnOutput(this, \"website-url\", {\n        value: this.distribution.domainName,\n        description: \"Website URL\",\n      });\n    }\n\n    if (props.previewConfig) {\n      this.previewEnvironment = new PreviewEnvironment(\n        this,\n        \"PreviewEnvironment\",\n        {\n          ...props.previewConfig,\n          indexFile: props.indexFile,\n          errorFile: props.errorFile,\n        },\n      );\n    }\n  }\n\n  private _getFullDomainName(domainConfig: DomainConfig): string {\n    return domainConfig.subdomainName\n      ? `${domainConfig.subdomainName}.${domainConfig.domainName}`\n      : domainConfig.domainName;\n  }\n\n  private _getCertificate(arn: string): certificatemanager.ICertificate {\n    return certificatemanager.Certificate.fromCertificateArn(\n      this,\n      `website-cert`,\n      arn,\n    );\n  }\n}\n\nexport class PreviewEnvironment extends Construct {\n  public readonly buckets: s3.Bucket[];\n  public readonly distributions: cloudfont.Distribution[];\n  public readonly leaseTable: dynamodb.Table;\n  public readonly api: apigateway.RestApi;\n  public readonly claimEndpoint: string;\n  public readonly heartbeatEndpoint: string;\n  public readonly releaseEndpoint: string;\n\n  constructor(scope: Construct, id: string, props: PreviewEnvironmentProps) {\n    super(scope, id);\n\n    const bucketCount = props.bucketCount ?? 2;\n    if (bucketCount < 1) {\n      throw new Error(\"bucketCount must be greater than or equal to 1\");\n    }\n\n    const indexFile = props.indexFile;\n    const errorFile = props.errorFile;\n    const createDistributions = props.createDistributions ?? true;\n    const maxLeaseHours = props.maxLeaseHours ?? 24;\n    const maxLeaseMs = cdk.Duration.hours(maxLeaseHours).toMilliseconds();\n\n    this.buckets = Array.from({ length: bucketCount }, (_, slotId) => {\n      const bucketName = `${props.bucketPrefix}-${slotId}`;\n      return new s3.Bucket(this, `PreviewBucket${slotId}`, {\n        bucketName,\n        websiteIndexDocument: indexFile,\n        websiteErrorDocument: errorFile,\n        publicReadAccess: true,\n        removalPolicy: cdk.RemovalPolicy.DESTROY,\n        autoDeleteObjects: true,\n        blockPublicAccess: s3.BlockPublicAccess.BLOCK_ACLS_ONLY,\n        accessControl: s3.BucketAccessControl.BUCKET_OWNER_FULL_CONTROL,\n        encryption: s3.BucketEncryption.S3_MANAGED,\n      });\n    });\n\n    this.distributions = createDistributions\n      ? this.buckets.map((bucket, slotId) => {\n          const oai = new cloudfont.OriginAccessIdentity(\n            this,\n            `PreviewOAI${slotId}`,\n          );\n          bucket.addToResourcePolicy(\n            new iam.PolicyStatement({\n              actions: [\"s3:GetObject\"],\n              resources: [bucket.arnForObjects(\"*\")],\n              principals: [\n                new iam.CanonicalUserPrincipal(\n                  oai.cloudFrontOriginAccessIdentityS3CanonicalUserId,\n                ),\n              ],\n            }),\n          );\n          return new cloudfont.Distribution(\n            this,\n            `PreviewDistribution${slotId}`,\n            {\n              defaultBehavior: {\n                origin: new origins.S3StaticWebsiteOrigin(bucket),\n                viewerProtocolPolicy:\n                  cloudfont.ViewerProtocolPolicy.REDIRECT_TO_HTTPS,\n              },\n              priceClass: cloudfont.PriceClass.PRICE_CLASS_100,\n            },\n          );\n        })\n      : [];\n\n    this.leaseTable = new dynamodb.Table(this, \"PreviewLeases\", {\n      partitionKey: {\n        name: \"slotId\",\n        type: dynamodb.AttributeType.STRING,\n      },\n      billingMode: dynamodb.BillingMode.PAY_PER_REQUEST,\n      removalPolicy: cdk.RemovalPolicy.DESTROY,\n      timeToLiveAttribute: \"ttlEpochSeconds\",\n    });\n    this.leaseTable.addGlobalSecondaryIndex({\n      indexName: \"RepoPrKeyIndex\",\n      partitionKey: {\n        name: \"repoPrKey\",\n        type: dynamodb.AttributeType.STRING,\n      },\n      projectionType: dynamodb.ProjectionType.ALL,\n    });\n\n    const slotDefinitions = this.buckets.map((bucket, slotId) => ({\n      slotId,\n      bucketName: bucket.bucketName,\n      previewUrl: this.distributions[slotId]\n        ? `https://${this.distributions[slotId].distributionDomainName}`\n        : bucket.bucketWebsiteUrl,\n    }));\n\n    const leaseApiHandler = new lambda.Function(\n      this,\n      \"PreviewLeaseApiHandler\",\n      {\n        runtime: lambda.Runtime.NODEJS_20_X,\n        handler: \"index.handler\",\n        timeout: cdk.Duration.seconds(15),\n        code: lambda.Code.fromAsset(path.join(__dirname, \"..\", \"lambda\")),\n        environment: {\n          TABLE_NAME: this.leaseTable.tableName,\n          SLOT_DEFINITIONS: JSON.stringify(slotDefinitions),\n          MAX_LEASE_MS: String(maxLeaseMs),\n        },\n      },\n    );\n\n    this.leaseTable.grantReadWriteData(leaseApiHandler);\n\n    this.api = new apigateway.RestApi(this, \"PreviewLeaseApi\", {\n      restApiName: `${cdk.Names.uniqueId(this)}-preview-lease-api`,\n      description: \"API for claiming/releasing preview slots\",\n    });\n\n    const claimResource = this.api.root.addResource(\"claim\");\n    claimResource.addMethod(\n      \"POST\",\n      new apigateway.LambdaIntegration(leaseApiHandler),\n    );\n    const heartbeatResource = this.api.root.addResource(\"heartbeat\");\n    heartbeatResource.addMethod(\n      \"POST\",\n      new apigateway.LambdaIntegration(leaseApiHandler),\n    );\n    const releaseResource = this.api.root.addResource(\"release\");\n    releaseResource.addMethod(\n      \"POST\",\n      new apigateway.LambdaIntegration(leaseApiHandler),\n    );\n\n    this.claimEndpoint = `${this.api.url}claim`;\n    this.heartbeatEndpoint = `${this.api.url}heartbeat`;\n    this.releaseEndpoint = `${this.api.url}release`;\n\n    new cdk.CfnOutput(this, \"preview-claim-endpoint\", {\n      value: this.claimEndpoint,\n      description: \"POST endpoint used to claim a preview slot\",\n    });\n    new cdk.CfnOutput(this, \"preview-heartbeat-endpoint\", {\n      value: this.heartbeatEndpoint,\n      description: \"POST endpoint used to refresh a preview slot lease\",\n    });\n    new cdk.CfnOutput(this, \"preview-release-endpoint\", {\n      value: this.releaseEndpoint,\n      description: \"POST endpoint used to release a preview slot\",\n    });\n  }\n\n  public grantDeploymentAccess(grantee: iam.IGrantable): void {\n    this.buckets.forEach((bucket) => bucket.grantReadWrite(grantee));\n    this.distributions.forEach((distribution) => {\n      grantee.grantPrincipal.addToPrincipalPolicy(\n        new iam.PolicyStatement({\n          actions: [\"cloudfront:CreateInvalidation\"],\n          resources: [distribution.distributionArn],\n        }),\n      );\n    });\n  }\n}\n"]}