alchemy 0.3.1 → 0.4.1

package/lib/cloudflare/bucket.js

@@ -1,5 +1,6 @@
+import { AwsClient } from "aws4fetch";
 import { Resource } from "../resource";
-import { createCloudflareApi } from "./api";
+import { CloudflareAccountId, CloudflareApi, CloudflareApiError, createCloudflareApi, handleApiError, } from "./api";
 /**
  * Creates and manages Cloudflare R2 Buckets for object storage.
  *
@@ -37,113 +38,292 @@ import { createCloudflareApi } from "./api";
  * @see https://developers.cloudflare.com/r2/buckets/
  */
 export const R2Bucket = Resource("cloudflare::R2Bucket", async function (id, props) {
-    // Create Cloudflare API client with automatic account discovery
-    const api = await createCloudflareApi();
-    // Resource ID defaults to bucket name if provided
+    const [api, r2Client] = await Promise.all([
+        createCloudflareApi(props),
+        createR2Client(props),
+    ]);
     const bucketName = props.name || this.id;
     if (this.phase === "delete") {
-        if (this.output?.name) {
+        console.log("Deleting R2 bucket:", bucketName);
+        if (props.delete !== false) {
+            // Empty the bucket first by deleting all objects
+            await emptyBucket(r2Client, bucketName, props.jurisdiction);
             // Delete R2 bucket
-            const headers = {};
-            if (props.jurisdiction && props.jurisdiction !== "default") {
-                headers["cf-r2-jurisdiction"] = props.jurisdiction;
-            }
-            const deleteResponse = await api.delete(`/accounts/${api.accountId}/r2/buckets/${this.output.name}`, { headers });
-            if (!deleteResponse.ok && deleteResponse.status !== 404) {
-                const errorData = await deleteResponse.json().catch(() => ({
-                    errors: [{ message: deleteResponse.statusText }],
-                }));
-                throw new Error(`Error deleting R2 bucket '${bucketName}': ${errorData.errors?.[0]?.message || deleteResponse.statusText}`);
-            }
+            console.log("Deleting R2 bucket:", bucketName);
+            await deleteBucket(api, bucketName, props);
         }
         // Return void (a deleted bucket has no content)
         return this.destroy();
     }
     else {
-        try {
-            let bucketOutput;
-            if (this.phase === "update" && this.output?.name) {
-                // Get bucket details to verify it exists
-                const headers = {};
-                if (props.jurisdiction && props.jurisdiction !== "default") {
-                    headers["cf-r2-jurisdiction"] = props.jurisdiction;
-                }
-                const getResponse = await api.get(`/accounts/${api.accountId}/r2/buckets/${bucketName}`, { headers });
-                if (!getResponse.ok) {
-                    const errorData = await getResponse.json().catch(() => ({
-                        errors: [{ message: getResponse.statusText }],
-                    }));
-                    throw new Error(`Error getting R2 bucket '${bucketName}': ${errorData.errors?.[0]?.message || getResponse.statusText}`);
-                }
-                const result = (await getResponse.json());
-                bucketOutput = this({
-                    name: result.result.name,
-                    location: result.result.location || "default",
-                    creationDate: Math.floor(new Date(result.result.creation_date).getTime() / 1000),
-                    jurisdiction: props.jurisdiction || "default",
-                    type: "r2_bucket",
-                });
-                // Update public access setting if it has changed
-                if (props.allowPublicAccess !== undefined) {
-                    await updatePublicAccess(api, bucketName, props.allowPublicAccess);
-                }
-            }
-            else {
-                // Create new R2 bucket
-                const createPayload = {
-                    name: bucketName,
-                };
-                if (props.locationHint) {
-                    createPayload.location_hint = props.locationHint;
-                }
-                const headers = {};
-                if (props.jurisdiction && props.jurisdiction !== "default") {
-                    headers["cf-r2-jurisdiction"] = props.jurisdiction;
-                }
-                const createResponse = await api.post(`/accounts/${api.accountId}/r2/buckets`, createPayload, { headers });
-                if (!createResponse.ok) {
-                    const errorData = await createResponse.json().catch(() => ({
-                        errors: [{ message: createResponse.statusText }],
-                    }));
-                    throw new Error(`Error creating R2 bucket '${bucketName}': ${errorData.errors?.[0]?.message || createResponse.statusText}`);
-                }
-                const result = (await createResponse.json());
-                bucketOutput = this({
-                    name: result.result.name,
-                    location: result.result.location || "default",
-                    creationDate: Math.floor(new Date(result.result.creation_date).getTime() / 1000),
-                    jurisdiction: props.jurisdiction || "default",
-                    type: "r2_bucket",
-                });
-                // Set public access if requested
-                if (props.allowPublicAccess) {
-                    await updatePublicAccess(api, bucketName, true);
+        if (this.phase === "create") {
+            console.log("Creating R2 bucket:", bucketName);
+            await createBucket(api, bucketName, props);
+        }
+        await updatePublicAccess(api, bucketName, props.allowPublicAccess === true, props.jurisdiction);
+        return this({
+            name: bucketName,
+            location: props.locationHint || "default",
+            creationDate: new Date(),
+            jurisdiction: props.jurisdiction || "default",
+            type: "r2_bucket",
+        });
+    }
+});
+/**
+ * Creates an aws4fetch client configured for Cloudflare R2
+ *
+ * @see https://developers.cloudflare.com/r2/examples/aws/aws-sdk-js-v3/
+ */
+export async function createR2Client(config = {}) {
+    const accountId = await CloudflareAccountId(config);
+    const accessKeyId = config.accessKeyId || process.env.R2_ACCESS_KEY_ID;
+    const secretAccessKey = config.secretAccessKey || process.env.R2_SECRET_ACCESS_KEY;
+    if (!accountId) {
+        throw new Error("CLOUDFLARE_ACCOUNT_ID environment variable is required");
+    }
+    if (!accessKeyId || !secretAccessKey) {
+        throw new Error("R2_ACCESS_KEY_ID and R2_SECRET_ACCESS_KEY environment variables are required");
+    }
+    // Create aws4fetch client with Cloudflare R2 endpoint
+    const client = new AwsClient({
+        accessKeyId,
+        secretAccessKey,
+        service: "s3",
+        region: "auto",
+    });
+    client.accountId = accountId;
+    return client;
+}
+/**
+ * Adds jurisdiction header to the headers object if specified in props
+ *
+ * @param headers Headers object to modify
+ * @param props Props or jurisdiction string
+ * @returns Modified headers object
+ */
+export function withJurisdiction(headers = {}, props) {
+    // Clone the headers object to avoid modifying the original
+    const result = { ...headers };
+    let jurisdiction;
+    if (typeof props === "string") {
+        jurisdiction = props;
+    }
+    else if (props && "jurisdiction" in props) {
+        jurisdiction = props.jurisdiction;
+    }
+    if (jurisdiction && jurisdiction !== "default") {
+        result["cf-r2-jurisdiction"] = jurisdiction;
+    }
+    return result;
+}
+/**
+ * Create a new bucket
+ */
+export async function createBucket(api, bucketName, props) {
+    // Create new R2 bucket
+    const createPayload = {
+        name: bucketName,
+    };
+    if (props.locationHint) {
+        createPayload.location_hint = props.locationHint;
+    }
+    const headers = withJurisdiction({}, props);
+    const createResponse = await api.post(`/accounts/${api.accountId}/r2/buckets`, createPayload, { headers });
+    if (!createResponse.ok) {
+        const errorData = await createResponse.json().catch(() => ({
+            errors: [{ message: createResponse.statusText }],
+        }));
+        throw new CloudflareApiError(`Error creating R2 bucket '${bucketName}': ${errorData.errors?.[0]?.message || createResponse.statusText}`, createResponse);
+    }
+    return (await createResponse.json());
+}
+/**
+ * Delete a bucket
+ */
+export async function deleteBucket(api, bucketName, props) {
+    // Delete R2 bucket
+    const headers = withJurisdiction({}, props);
+    const deleteResponse = await api.delete(`/accounts/${api.accountId}/r2/buckets/${bucketName}`, { headers });
+    if (!deleteResponse.ok && deleteResponse.status !== 404) {
+        const errorData = await deleteResponse.json().catch(() => ({
+            errors: [{ message: deleteResponse.statusText }],
+        }));
+        throw new CloudflareApiError(`Error deleting R2 bucket '${bucketName}': ${errorData.errors?.[0]?.message || deleteResponse.statusText}`, deleteResponse);
+    }
+}
+/**
+ * List objects in an R2 bucket
+ *
+ * @param r2 R2Client instance
+ * @param bucketName Name of the bucket
+ * @param continuationToken Optional token for pagination
+ * @param jurisdiction Optional jurisdiction for the bucket
+ * @returns Object containing the list of objects and the next continuation token
+ */
+export async function listObjects(r2, bucketName, continuationToken, jurisdiction) {
+    // List objects in the bucket
+    const url = new URL(`https://${r2.accountId}.r2.cloudflarestorage.com/${bucketName}`);
+    if (continuationToken) {
+        url.searchParams.set("continuation-token", continuationToken);
+    }
+    url.searchParams.set("list-type", "2");
+    const headers = withJurisdiction({}, jurisdiction);
+    const listResponse = await r2.fetch(url.toString(), { headers });
+    if (!listResponse.ok) {
+        throw new CloudflareApiError(`Failed to list objects: ${listResponse.statusText}`, listResponse);
+    }
+    const responseText = await listResponse.text();
+    // Extract objects from XML response using regex
+    const keyRegex = /<Key>([^<]+)<\/Key>/g;
+    const objects = [];
+    let match;
+    while ((match = keyRegex.exec(responseText)) !== null) {
+        objects.push({ Key: match[1] });
+    }
+    // Get continuation token if present using regex
+    const tokenMatch = /<NextContinuationToken>([^<]+)<\/NextContinuationToken>/.exec(responseText);
+    const nextContinuationToken = tokenMatch ? tokenMatch[1] : undefined;
+    return { objects, continuationToken: nextContinuationToken };
+}
+/**
+ * Helper function to empty a bucket by deleting all objects
+ */
+export async function emptyBucket(r2, bucketName, jurisdiction) {
+    let continuationToken;
+    let totalDeleted = 0;
+    try {
+        do {
+            // List objects in the bucket
+            const { objects, continuationToken: nextToken } = await listObjects(r2, bucketName, continuationToken, jurisdiction);
+            continuationToken = nextToken;
+            console.log(`Found ${objects.length} objects in bucket ${bucketName}`);
+            // Delete objects in batches
+            if (objects.length > 0) {
+                // Process delete in batches of 1000 (S3 limit)
+                for (let i = 0; i < objects.length; i += 1000) {
+                    const batch = objects.slice(i, i + 1000);
+                    // Create DeleteObjects request XML
+                    const deleteXml = `
+            <Delete>
+              ${batch.map((obj) => `<Object><Key>${obj.Key}</Key></Object>`).join("")}
+            </Delete>
+          `;
+                    const deleteUrl = new URL(`https://${r2.accountId}.r2.cloudflarestorage.com/${bucketName}?delete`);
+                    console.log(`Deleting ${batch.length} objects from bucket ${bucketName}`);
+                    const headers = withJurisdiction({ "Content-Type": "application/xml" }, jurisdiction);
+                    const deleteResponse = await r2.fetch(deleteUrl.toString(), {
+                        method: "POST",
+                        body: deleteXml,
+                        headers,
+                    });
+                    if (!deleteResponse.ok) {
+                        throw new CloudflareApiError(`Failed to delete objects: ${deleteResponse.statusText}`, deleteResponse);
+                    }
+                    totalDeleted += batch.length;
                 }
             }
-            return bucketOutput;
-        }
-        catch (error) {
-            console.error("Error creating/updating R2 bucket:", error);
-            throw error;
+        } while (continuationToken);
+        console.log(`Successfully emptied bucket ${bucketName}, deleted ${totalDeleted} objects total`);
+    }
+    catch (error) {
+        if (error instanceof CloudflareApiError && error.status === 404) {
+            // the bucket was not found
+            return;
         }
+        console.error(`Failed to empty bucket ${bucketName}:`, error);
+        throw error;
     }
-});
+}
+/**
+ * Update public access setting for a bucket
+ *
+ * This operation is not available through the S3 API for R2,
+ * so we still use the Cloudflare API directly.
+ */
+export async function updatePublicAccess(api, bucketName, allowPublicAccess, jurisdiction) {
+    console.log(`/accounts/${api.accountId}/r2/buckets/${bucketName}/domains/managed`);
+    const headers = withJurisdiction({}, jurisdiction);
+    const response = await api.put(`/accounts/${api.accountId}/r2/buckets/${bucketName}/domains/managed`, {
+        enabled: allowPublicAccess,
+    }, { headers });
+    if (!response.ok) {
+        await handleApiError(response, "updating public access for", "R2 bucket", bucketName);
+    }
+}
 /**
- * Helper function to update the public access setting for a bucket
+ * Set CORS configuration for a bucket using aws4fetch
  */
-async function updatePublicAccess(api, bucketName, allowPublicAccess) {
+export async function setCorsConfiguration(r2, bucketName, allowedOrigins = ["*"], allowedMethods = ["GET", "HEAD", "PUT", "POST", "DELETE"], allowedHeaders = ["*"], maxAgeSeconds = 3600, jurisdiction) {
     try {
-        const response = await api.put(`/accounts/${api.accountId}/r2/buckets/${bucketName}/domains/managed`, {
-            enabled: allowPublicAccess,
+        // Construct CORS XML configuration
+        const corsXml = `
+      <CORSConfiguration>
+        <CORSRule>
+          ${allowedOrigins.map((origin) => `<AllowedOrigin>${origin}</AllowedOrigin>`).join("")}
+          ${allowedMethods.map((method) => `<AllowedMethod>${method}</AllowedMethod>`).join("")}
+          ${allowedHeaders.map((header) => `<AllowedHeader>${header}</AllowedHeader>`).join("")}
+          <ExposeHeader>ETag</ExposeHeader>
+          <MaxAgeSeconds>${maxAgeSeconds}</MaxAgeSeconds>
+        </CORSRule>
+      </CORSConfiguration>
+    `;
+        const url = new URL(`https://${r2.accountId}.r2.cloudflarestorage.com/${bucketName}?cors`);
+        const headers = withJurisdiction({ "Content-Type": "application/xml" }, jurisdiction);
+        const response = await r2.fetch(url.toString(), {
+            method: "PUT",
+            body: corsXml,
+            headers,
         });
         if (!response.ok) {
-            const errorData = await response.json().catch(() => ({
-                errors: [{ message: response.statusText }],
-            }));
-            throw new Error(`Error updating R2 bucket public access: ${errorData.errors?.[0]?.message || response.statusText}`);
+            throw new CloudflareApiError(`Failed to set CORS configuration: ${response.statusText}`, response);
         }
+        console.log(`Successfully set CORS configuration for bucket ${bucketName}`);
     }
     catch (error) {
-        console.warn("Could not set public access:", error);
+        console.error(`Failed to set CORS configuration for bucket ${bucketName}:`, error);
+        throw error;
+    }
+}
+/**
+ * List all R2 buckets in an account
+ *
+ * @param api CloudflareApi instance
+ * @param options Optional listing options
+ * @returns Array of bucket information
+ */
+export async function listBuckets(api, options = {}) {
+    // Build query parameters
+    const params = new URLSearchParams();
+    if (options.nameContains) {
+        params.append("name_contains", options.nameContains);
+    }
+    if (options.perPage) {
+        params.append("per_page", options.perPage.toString());
+    }
+    if (options.cursor) {
+        params.append("cursor", options.cursor);
+    }
+    if (options.direction) {
+        params.append("direction", options.direction);
+    }
+    // Build URL with query parameters
+    const path = `/accounts/${api.accountId}/r2/buckets${params.toString() ? "?" + params.toString() : ""}`;
+    // Set jurisdiction header if provided
+    const headers = withJurisdiction({}, options.jurisdiction);
+    // Make the API request
+    const response = await api.get(path, { headers });
+    if (!response.ok) {
+        throw new CloudflareApiError(`Failed to list buckets: ${response.statusText}`, response);
+    }
+    const data = (await response.json());
+    if (!data.success) {
+        const errorMessage = data.errors?.[0]?.message || "Unknown error";
+        throw new Error(`Failed to list buckets: ${errorMessage}`);
     }
+    // Transform API response to R2BucketInfo objects
+    return (data.result?.buckets || []).map((bucket) => ({
+        Name: bucket.name,
+        CreationDate: new Date(bucket.creation_date),
+    }));
 }

package/lib/cloudflare/custom-domain.d.ts

@@ -0,0 +1,75 @@
+import type { Context } from "../context";
+import { Resource } from "../resource";
+/**
+ * Properties for creating or updating a CustomDomain
+ */
+export interface CustomDomainProps {
+    /**
+     * The domain name to bind to the worker
+     */
+    name: string;
+    /**
+     * Cloudflare Zone ID for the domain
+     */
+    zoneId: string;
+    /**
+     * Name of the worker to bind to the domain
+     */
+    workerName: string;
+    /**
+     * Worker environment (defaults to production)
+     * @default "production"
+     */
+    environment?: string;
+}
+/**
+ * Output returned after CustomDomain creation/update
+ */
+export interface CustomDomain extends Resource<"cloudflare::CustomDomain">, CustomDomainProps {
+    /**
+     * The unique identifier for the Cloudflare domain binding.
+     */
+    id: string;
+    /**
+     * Time at which the domain binding was created (approximated if not returned by API)
+     */
+    createdAt: number;
+    /**
+     * Time at which the domain binding was last updated
+     */
+    updatedAt: number;
+}
+/**
+ * Configure custom domain for a Cloudflare Worker using the Cloudflare Custom Domains API
+ * This attaches a worker (either a standard Worker or the one backing a StaticSite)
+ * to a specific hostname within a zone.
+ *
+ * @example
+ * // Bind a domain to a standard Cloudflare Worker
+ * const apiWorker = await Worker("api", {
+ *   name: "my-api-worker",
+ *   entrypoint: "./src/api-worker.ts"
+ * });
+ *
+ * const apiDomain = await CustomDomain("api-domain-binding", {
+ *   name: "api.example.com",
+ *   zoneId: "YOUR_ZONE_ID", // Replace with actual Zone ID
+ *   workerName: apiWorker.name // Use the name from the Worker resource
+ * });
+ *
+ * @example
+ * // Bind a domain to a Cloudflare Static Site
+ * const mySite = await StaticSite("landing-page", {
+ *   name: "my-landing-page-site", // This becomes the underlying worker name
+ *   dir: "./dist/landing-page"
+ * });
+ *
+ * const siteDomain = await CustomDomain("site-domain-binding", {
+ *   name: "www.example.com",
+ *   zoneId: "YOUR_ZONE_ID", // Replace with actual Zone ID
+ *   workerName: mySite.name // Use the name from the StaticSite resource
+ * });
+ *
+ * @see https://developers.cloudflare.com/api/resources/workers/subresources/domains/
+ */
+export declare const CustomDomain: (((this: any, id: string, props?: {}) => never) & (new (_: never) => never)) | ((this: Context<CustomDomain>, logicalId: string, props: CustomDomainProps) => Promise<CustomDomain>);

package/lib/cloudflare/custom-domain.js

@@ -0,0 +1,154 @@
+import { Resource } from "../resource";
+import { CloudflareApi, createCloudflareApi, handleApiError } from "./api";
+/**
+ * Configure custom domain for a Cloudflare Worker using the Cloudflare Custom Domains API
+ * This attaches a worker (either a standard Worker or the one backing a StaticSite)
+ * to a specific hostname within a zone.
+ *
+ * @example
+ * // Bind a domain to a standard Cloudflare Worker
+ * const apiWorker = await Worker("api", {
+ *   name: "my-api-worker",
+ *   entrypoint: "./src/api-worker.ts"
+ * });
+ *
+ * const apiDomain = await CustomDomain("api-domain-binding", {
+ *   name: "api.example.com",
+ *   zoneId: "YOUR_ZONE_ID", // Replace with actual Zone ID
+ *   workerName: apiWorker.name // Use the name from the Worker resource
+ * });
+ *
+ * @example
+ * // Bind a domain to a Cloudflare Static Site
+ * const mySite = await StaticSite("landing-page", {
+ *   name: "my-landing-page-site", // This becomes the underlying worker name
+ *   dir: "./dist/landing-page"
+ * });
+ *
+ * const siteDomain = await CustomDomain("site-domain-binding", {
+ *   name: "www.example.com",
+ *   zoneId: "YOUR_ZONE_ID", // Replace with actual Zone ID
+ *   workerName: mySite.name // Use the name from the StaticSite resource
+ * });
+ *
+ * @see https://developers.cloudflare.com/api/resources/workers/subresources/domains/
+ */
+export const CustomDomain = Resource("cloudflare::CustomDomain", async function (logicalId, // Changed param name from id to logicalId for clarity
+props) {
+    // Create Cloudflare API client with automatic account discovery
+    const api = await createCloudflareApi();
+    // Validate required properties
+    if (!props.name) {
+        throw new Error("Domain name (props.name) is required");
+    }
+    if (!props.zoneId) {
+        throw new Error("Zone ID (props.zoneId) is required");
+    }
+    if (!props.workerName) {
+        throw new Error("Worker name (props.workerName) is required");
+    }
+    if (this.phase === "delete") {
+        await deleteCustomDomain(this, api, logicalId, props);
+        return this.destroy();
+    }
+    else {
+        // Create or Update phase
+        return await ensureCustomDomain(this, api, logicalId, props);
+    }
+});
+// Helper function to delete the custom domain binding
+async function deleteCustomDomain(context, api, logicalId, props) {
+    const domainHostname = props.name;
+    const domainIdToDelete = context.output?.id;
+    if (!domainIdToDelete) {
+        console.warn(`Cannot delete CustomDomain ${logicalId} (${domainHostname}): Missing domain ID in state. Assuming already deleted.`);
+        return; // Exit early if no ID
+    }
+    console.log(`Deleting CustomDomain binding ${domainIdToDelete} for ${domainHostname}`);
+    const response = await api.delete(`/accounts/${api.accountId}/workers/domains/${domainIdToDelete}`);
+    console.log(`Delete result for ${domainIdToDelete} (${domainHostname}):`, response.status, response.statusText);
+    // 404 is acceptable during deletion for idempotency
+    if (!response.ok && response.status !== 404) {
+        await handleApiError(response, "deleting", "custom domain binding", domainIdToDelete);
+        // Throw after handling to ensure failure is reported
+        throw new Error(`Failed to delete custom domain binding ${domainIdToDelete}: ${response.statusText}`);
+    }
+}
+// Helper function to create or update the custom domain binding
+async function ensureCustomDomain(context, api, logicalId, props) {
+    const environment = props.environment || "production";
+    const domainHostname = props.name;
+    // Check if domain binding already exists for this account
+    console.log(`Checking existing domain bindings for account ${api.accountId}`);
+    const listResponse = await api.get(`/accounts/${api.accountId}/workers/domains`);
+    if (!listResponse.ok) {
+        // Fix: Added the 4th argument (resource identifier/context)
+        await handleApiError(listResponse, "listing", "worker domains", `Account ${api.accountId}`);
+        // If listing fails, we cannot proceed reliably
+        throw new Error(`Failed to list worker domains for account ${api.accountId}: ${listResponse.statusText}`);
+    }
+    const listData = (await listResponse.json());
+    if (!listData.success || !listData.result) {
+        throw new Error(`Failed to parse list worker domains response: ${JSON.stringify(listData)}`);
+    }
+    // Find the specific binding by hostname AND zoneId
+    const existingBinding = listData.result.find((b) => b.hostname === domainHostname && b.zone_id === props.zoneId);
+    let currentDomainId = existingBinding?.id;
+    const bindingExists = !!existingBinding;
+    console.log(`Domain binding status for ${domainHostname} (Zone: ${props.zoneId}):`, bindingExists
+        ? `Found (ID: ${currentDomainId}, Worker: ${existingBinding.service}, Env: ${existingBinding.environment})`
+        : "Not found");
+    // Determine if we need to update (binding exists but has different service or environment)
+    const needsUpdate = bindingExists &&
+        (existingBinding.service !== props.workerName ||
+            existingBinding.environment !== environment);
+    let operationPerformed = "none";
+    let resultantBinding = existingBinding;
+    // Create or Update the binding using PUT
+    // Cloudflare's PUT /accounts/{account_id}/workers/domains acts as an upsert
+    if (!bindingExists || needsUpdate) {
+        operationPerformed = bindingExists ? "update" : "create";
+        console.log(`${operationPerformed === "update" ? "Updating" : "Creating"} domain binding: ${domainHostname} (Zone: ${props.zoneId}) → ${props.workerName}:${environment}`);
+        const putPayload = {
+            zone_id: props.zoneId,
+            hostname: domainHostname,
+            service: props.workerName,
+            environment: environment,
+        };
+        const putResponse = await api.put(`/accounts/${api.accountId}/workers/domains`, putPayload);
+        if (!putResponse.ok) {
+            await handleApiError(putResponse, operationPerformed === "update" ? "updating" : "creating", "custom domain binding", domainHostname);
+            // Throw after handling to prevent inconsistent state
+            throw new Error(`Failed to ${operationPerformed} custom domain binding: ${putResponse.statusText}`);
+        }
+        const putResult = (await putResponse.json());
+        if (!putResult.success || !putResult.result) {
+            throw new Error(`Failed to parse ${operationPerformed} domain binding response: ${JSON.stringify(putResult)}`);
+        }
+        resultantBinding = putResult.result;
+        currentDomainId = resultantBinding.id; // Update ID from the PUT response
+        console.log(`Successfully ${operationPerformed}d binding, new ID: ${currentDomainId}`);
+    }
+    else {
+        console.log(`Domain binding already exists and is up to date: ${domainHostname} (ID: ${currentDomainId}) → ${props.workerName}:${environment}`);
+    }
+    // Ensure we have the final binding details
+    if (!resultantBinding || !currentDomainId) {
+        // This case should ideally not happen if API calls succeed
+        console.error("Error: Could not determine final domain binding state.", {
+            existingBinding,
+            resultantBinding,
+            currentDomainId,
+        });
+        throw new Error(`Failed to get final state for custom domain ${domainHostname}`);
+    }
+    const now = Date.now();
+    // Construct the output state
+    return context({
+        ...props, // Include all input props
+        id: currentDomainId, // Use the definitive ID
+        environment: resultantBinding.environment, // Use actual environment from CF
+        createdAt: context.output?.createdAt || now, // Preserve create time or set new
+        updatedAt: operationPerformed !== "none" ? now : context.output?.updatedAt || now, // Update time only if changed
+    });
+}

package/lib/cloudflare/{dns.js → dns-records.js}

@@ -111,7 +111,20 @@ export const DnsRecords = Resource("cloudflare::DnsRecords", async function (id,
     }
     // Create new records
     const uniqueRecords = props.records.reduce((acc, record) => {
-        const key = `${record.name}-${record.type}`;
+        // For record types that can have multiple entries with the same name (MX, TXT, NS, etc.),
+        // include content and/or priority in the key to avoid deduplication
+        let key = `${record.name}-${record.type}`;
+        // If it's a record type that can have multiple entries with the same name, make the key unique
+        if (["MX", "TXT", "NS", "SRV", "CAA"].includes(record.type)) {
+            // For MX, include priority in the key
+            if (record.type === "MX" || record.type === "SRV") {
+                key = `${key}-${record.priority}-${record.content}`;
+            }
+            else {
+                // For other multi-record types, content is the differentiator
+                key = `${key}-${record.content}`;
+            }
+        }
         acc[key] = record;
         return acc;
     }, {});

package/lib/cloudflare/index.d.ts

@@ -1,8 +1,13 @@
+export * from "./account-api-token";
+export * from "./api";
+export * from "./assets";
 export * from "./bindings";
 export * from "./bucket";
-export * from "./dns";
+export * from "./custom-domain";
+export * from "./dns-records";
 export * from "./durable-object-namespace";
 export * from "./kv-namespace";
+export * from "./permission-groups";
 export * from "./r2-rest-state-store";
 export * from "./static-site";
 export * from "./worker";