@sitblueprint/website-construct 0.1.4 → 0.1.6

package/README.md

@@ -6,6 +6,7 @@ A reusable [AWS CDK](https://docs.aws.amazon.com/cdk/) construct to deploy a web
 
 - CDN caching via CloudFont
 - Deployment via S3
+- Dual domain support (e.g., deploy to both `www.example.com` and `example.com` simultaneously)
 - Hardened S3 bucket defaults with bucket-owner-only ACLs and automatic SSE
 - Direct access to the underlying S3 bucket and CloudFront distribution for advanced customization
 
@@ -39,6 +40,7 @@ export class MyWebsiteStack extends cdk.Stack {
         domainName: "example.com",
         subdomainName: "www",
         certificateArn: "arn:aws:acm:us-east-1:123456789012:certificate/abc123",
+        includeRootDomain: true, // Optional: also deploy to example.com
       },
     });
 
@@ -48,6 +50,89 @@ export class MyWebsiteStack extends cdk.Stack {
 }
 ```
 
+## Pull Request Preview Environments
+
+Use `previewConfig` on `Website` to create a pool of preview buckets (default: 2). CI can claim a slot using LRU, deploy artifacts to the assigned bucket, and release the slot when the pull request closes.
+
+```ts
+export class WebsiteWithPreviewStack extends cdk.Stack {
+  constructor(scope: cdk.App, id: string, props?: cdk.StackProps) {
+    super(scope, id, props);
+
+    const website = new Website(this, "MyWebsite", {
+      bucketName: "my-static-site-bucket",
+      indexFile: "index.html",
+      errorFile: "error.html",
+      previewConfig: {
+        bucketPrefix: "my-frontend-preview",
+        bucketCount: 2, // default
+        maxLeaseHours: 24,
+      },
+    });
+
+    new cdk.CfnOutput(this, "PreviewClaimEndpoint", {
+      value: website.previewEnvironment!.claimEndpoint,
+    });
+    new cdk.CfnOutput(this, "PreviewReleaseEndpoint", {
+      value: website.previewEnvironment!.releaseEndpoint,
+    });
+  }
+}
+```
+
+### API contract for CI
+
+- `POST /claim` with body `{"repo":"owner/repo","prNumber":123,"commitSha":"abc"}`
+- `POST /heartbeat` with body `{"repo":"owner/repo","prNumber":123,"commitSha":"abc"}`
+- `POST /release` with body `{"repo":"owner/repo","prNumber":123}`
+
+`claim` and `heartbeat` return:
+
+```json
+{
+  "slotId": 0,
+  "bucketName": "my-frontend-preview-0",
+  "previewUrl": "https://....cloudfront.net"
+}
+```
+
+### GitHub Actions shape
+
+```yaml
+name: preview
+on:
+  pull_request:
+    types: [opened, reopened, synchronize, closed]
+
+jobs:
+  preview:
+    runs-on: ubuntu-latest
+    concurrency: preview-${{ github.event.pull_request.number }}
+    steps:
+      - uses: actions/checkout@v4
+      - if: github.event.action != 'closed'
+        run: npm ci && npm run build
+      - name: Claim or release slot
+        env:
+          REPO: ${{ github.repository }}
+          PR: ${{ github.event.pull_request.number }}
+          SHA: ${{ github.sha }}
+          CLAIM_URL: ${{ secrets.PREVIEW_CLAIM_ENDPOINT }}
+          RELEASE_URL: ${{ secrets.PREVIEW_RELEASE_ENDPOINT }}
+        run: |
+          if [ "${{ github.event.action }}" = "closed" ]; then
+            curl -sS -X POST "$RELEASE_URL" -H "content-type: application/json" -d "{\"repo\":\"$REPO\",\"prNumber\":$PR}"
+            exit 0
+          fi
+
+          RESPONSE=$(curl -sS -X POST "$CLAIM_URL" -H "content-type: application/json" -d "{\"repo\":\"$REPO\",\"prNumber\":$PR,\"commitSha\":\"$SHA\"}")
+          echo "$RESPONSE" > preview-slot.json
+          BUCKET=$(jq -r '.bucketName' preview-slot.json)
+          URL=$(jq -r '.previewUrl' preview-slot.json)
+          aws s3 sync ./dist "s3://$BUCKET" --delete
+          echo "Preview URL: $URL"
+```
+
 ## Development
 
 - Build: `npm run build`

package/docs/CHANGELOG.md

@@ -7,6 +7,32 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ---
 
+## [v0.1.6] - 2026-02-15
+
+### Added
+
+- `PreviewConfig` on `WebsiteProps` to enable pull request preview environments from the `Website` construct.
+- Preview slot infrastructure with configurable bucket pool size (`bucketCount`, default `2`), LRU lease behavior, and optional per-slot CloudFront distributions.
+- Preview lease API endpoints for CI workflows:
+  - `POST /claim`
+  - `POST /heartbeat`
+  - `POST /release`
+- DynamoDB-backed lease state with `RepoPrKeyIndex` for PR-to-slot lookup.
+- `previewEnvironment` exposure on `Website` for accessing endpoints and resources from downstream stacks.
+- `grantDeploymentAccess(...)` helper to grant CI principals access to preview buckets and CloudFront invalidation.
+
+### Changed
+
+- Refactored preview lease Lambda source from inline code to `lambda/index.ts` for better maintainability.
+- Updated tests to validate preview behavior via `Website.previewConfig` instead of constructing preview infrastructure directly.
+- Updated README preview usage to configure previews through `Website`.
+
+## [v0.1.5]
+
+### Added
+
+- `includeRootDomain` option to `DomainConfig` to deploy to both subdomain and root domain simultaneously.
+
 ## [v0.1.4] - 2025-09-30
 
 ### Security

package/lambda/index.d.ts

@@ -0,0 +1,11 @@
+type APIGatewayProxyEvent = {
+    body: string | null;
+    path: string;
+};
+type APIGatewayProxyResult = {
+    statusCode: number;
+    headers: Record<string, string>;
+    body: string;
+};
+export declare const handler: (event: APIGatewayProxyEvent) => Promise<APIGatewayProxyResult>;
+export {};

package/lambda/index.js

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