alchemy 0.5.2 → 0.7.0

package/lib/cloudflare/kv-namespace.js

@@ -1,6 +1,7 @@
 import { Resource } from "../resource";
 import { withExponentialBackoff } from "../util/retry";
-import { createCloudflareApi } from "./api";
+import { CloudflareApi, createCloudflareApi, } from "./api";
+import { handleApiError } from "./api-error";
 export function isKVNamespace(resource) {
     return (resource && typeof resource === "object" && resource.type === "kv_namespace");
 }
@@ -42,19 +43,12 @@ export function isKVNamespace(resource) {
  */
 export const KVNamespace = Resource("cloudflare::KVNamespace", async function (id, props) {
     // Create Cloudflare API client with automatic account discovery
-    const api = await createCloudflareApi();
+    const api = await createCloudflareApi(props);
     if (this.phase === "delete") {
         // For delete operations, we need to check if the namespace ID exists in the output
         const namespaceId = this.output?.namespaceId;
         if (namespaceId) {
-            // Delete KV namespace
-            const deleteResponse = await api.delete(`/accounts/${api.accountId}/storage/kv/namespaces/${namespaceId}`);
-            if (!deleteResponse.ok && deleteResponse.status !== 404) {
-                const errorData = await deleteResponse.json().catch(() => ({
-                    errors: [{ message: deleteResponse.statusText }],
-                }));
-                throw new Error(`Error deleting KV namespace '${props.title}': ${errorData.errors?.[0]?.message || deleteResponse.statusText}`);
-            }
+            await deleteKVNamespace(api, namespaceId);
         }
         // Return minimal output for deleted state
         return this.destroy();
@@ -71,69 +65,11 @@ export const KVNamespace = Resource("cloudflare::KVNamespace", async function (i
         }
         else {
             // TODO: if it already exists, then check the tags to see if we own it and continue
-            // Create new KV namespace
-            const createResponse = await api.post(`/accounts/${api.accountId}/storage/kv/namespaces`, {
-                title: props.title,
-            });
-            if (!createResponse.ok) {
-                const errorData = await createResponse.json().catch(() => ({
-                    errors: [{ message: createResponse.statusText }],
-                }));
-                throw new Error(`Error creating KV namespace '${props.title}': ${errorData.errors?.[0]?.message || createResponse.statusText}`);
-            }
-            const createResult = await createResponse.json();
-            namespaceId = createResult.result.id;
+            const { id } = await createKVNamespace(api, props);
             createdAt = Date.now();
+            namespaceId = id;
         }
-        // Handle KV pairs if provided
-        if (props.values && props.values.length > 0 && namespaceId) {
-            // Process KV pairs in batches of 10000 (API limit)
-            const BATCH_SIZE = 10000;
-            for (let i = 0; i < props.values.length; i += BATCH_SIZE) {
-                const batch = props.values.slice(i, i + BATCH_SIZE);
-                const bulkPayload = batch.map((entry) => {
-                    const item = {
-                        key: entry.key,
-                        value: typeof entry.value === "string"
-                            ? entry.value
-                            : JSON.stringify(entry.value),
-                    };
-                    if (entry.expiration) {
-                        item.expiration = entry.expiration;
-                    }
-                    if (entry.expirationTtl) {
-                        item.expiration_ttl = entry.expirationTtl;
-                    }
-                    if (entry.metadata) {
-                        item.metadata = entry.metadata;
-                    }
-                    return item;
-                });
-                try {
-                    await withExponentialBackoff(async () => {
-                        const bulkResponse = await api.put(`/accounts/${api.accountId}/storage/kv/namespaces/${namespaceId}/bulk`, bulkPayload);
-                        if (!bulkResponse.ok) {
-                            const errorData = await bulkResponse
-                                .json()
-                                .catch(() => ({
-                                errors: [{ message: bulkResponse.statusText }],
-                            }));
-                            const errorMessage = errorData.errors?.[0]?.message || bulkResponse.statusText;
-                            // Throw error to trigger retry
-                            throw new Error(`Error writing KV batch: ${errorMessage}`);
-                        }
-                        return bulkResponse;
-                    }, (error) => {
-                        // Retry on "namespace not found" errors as they're likely propagation delays
-                        return error.message?.includes("not found");
-                    }, 5, // 5 retry attempts
-                    1000);
-                }
-                catch (error) {
-                    console.warn(error.message);
-                }
-            }
-        }
+        await insertKVRecords(api, namespaceId, props);
         return this({
             type: "kv_namespace",
             namespaceId: namespaceId,
@@ -144,3 +80,68 @@ export const KVNamespace = Resource("cloudflare::KVNamespace", async function (i
         });
     }
 });
+export async function createKVNamespace(api, props) {
+    const createResponse = await api.post(`/accounts/${api.accountId}/storage/kv/namespaces`, {
+        title: props.title,
+    });
+    if (!createResponse.ok) {
+        await handleApiError(createResponse, "create", "kv_namespace", props.title);
+    }
+    return { id: (await createResponse.json()).result.id };
+}
+export async function deleteKVNamespace(api, namespaceId) {
+    // Delete KV namespace
+    const deleteResponse = await api.delete(`/accounts/${api.accountId}/storage/kv/namespaces/${namespaceId}`);
+    if (!deleteResponse.ok && deleteResponse.status !== 404) {
+        await handleApiError(deleteResponse, "delete", "kv_namespace", namespaceId);
+    }
+}
+export async function insertKVRecords(api, namespaceId, props) {
+    if (props.values && props.values.length > 0) {
+        // Process KV pairs in batches of 10000 (API limit)
+        const BATCH_SIZE = 10000;
+        for (let i = 0; i < props.values.length; i += BATCH_SIZE) {
+            const batch = props.values.slice(i, i + BATCH_SIZE);
+            const bulkPayload = batch.map((entry) => {
+                const item = {
+                    key: entry.key,
+                    value: typeof entry.value === "string"
+                        ? entry.value
+                        : JSON.stringify(entry.value),
+                };
+                if (entry.expiration) {
+                    item.expiration = entry.expiration;
+                }
+                if (entry.expirationTtl) {
+                    item.expiration_ttl = entry.expirationTtl;
+                }
+                if (entry.metadata) {
+                    item.metadata = entry.metadata;
+                }
+                return item;
+            });
+            try {
+                await withExponentialBackoff(async () => {
+                    const bulkResponse = await api.put(`/accounts/${api.accountId}/storage/kv/namespaces/${namespaceId}/bulk`, bulkPayload);
+                    if (!bulkResponse.ok) {
+                        const errorData = await bulkResponse.json().catch(() => ({
+                            errors: [{ message: bulkResponse.statusText }],
+                        }));
+                        const errorMessage = errorData.errors?.[0]?.message || bulkResponse.statusText;
+                        // Throw error to trigger retry
+                        throw new Error(`Error writing KV batch: ${errorMessage}`);
+                    }
+                    return bulkResponse;
+                }, (error) => {
+                    // Retry on "namespace not found" errors as they're likely propagation delays
+                    return error.message?.includes("not found");
+                }, 5, // 5 retry attempts
+                1000 // Start with 1 second delay
+                );
+            }
+            catch (error) {
+                console.warn(error.message);
+            }
+        }
+    }
+}

package/lib/cloudflare/permission-groups.d.ts

@@ -53,6 +53,10 @@ export type PermissionGroups = Resource<"cloudflare::PermissionGroups"> & {
  *
  * This is primarily used when creating API tokens for Cloudflare services like R2.
  *
+ * Note: Requires a Cloudflare API Key or Token with account read access.
+ * The API token must have permission to read token permission groups.
+ * The OAuth token from `wrangler login` is NOT sufficient for this operation.
+ *
  * @example
  * // Get all permission groups including those for R2
  * const permissions = await PermissionGroups("cloudflare-permissions");

package/lib/cloudflare/permission-groups.js

@@ -6,6 +6,10 @@ import { createCloudflareApi } from "./api";
  *
  * This is primarily used when creating API tokens for Cloudflare services like R2.
  *
+ * Note: Requires a Cloudflare API Key or Token with account read access.
+ * The API token must have permission to read token permission groups.
+ * The OAuth token from `wrangler login` is NOT sufficient for this operation.
+ *
  * @example
  * // Get all permission groups including those for R2
  * const permissions = await PermissionGroups("cloudflare-permissions");
@@ -28,7 +32,7 @@ import { createCloudflareApi } from "./api";
  *   ]
  * });
  */
-export const PermissionGroups = Resource("cloudflare::PermissionGroups", async function (id, options) {
+export const PermissionGroups = Resource("cloudflare::PermissionGroups", async function (id, options = {}) {
     // Only create and update phases are supported
     if (this.phase === "delete") {
         return this.destroy();

package/lib/cloudflare/r2-rest-state-store.d.ts

@@ -1,10 +1,10 @@
 import type { Scope } from "../scope";
-import type { Secret } from "../secret";
 import type { State, StateStore } from "../state";
+import { type CloudflareApiOptions } from "./api";
 /**
  * Options for CloudflareR2StateStore
  */
-export interface CloudflareR2StateStoreOptions {
+export interface CloudflareR2StateStoreOptions extends CloudflareApiOptions {
     /**
      * The prefix to use for object keys in the R2 bucket
      * This allows multiple state stores to use the same R2 bucket
@@ -15,18 +15,6 @@ export interface CloudflareR2StateStoreOptions {
      * Required - the bucket must already exist
      */
     bucketName: string;
-    /**
-     * API key to use (overrides CLOUDFLARE_API_KEY env var)
-     */
-    apiKey?: Secret;
-    /**
-     * Account ID to use (overrides CLOUDFLARE_ACCOUNT_ID env var)
-     */
-    accountId?: string;
-    /**
-     * Email to use with API Key authentication (overrides CLOUDFLARE_EMAIL env var)
-     */
-    email?: string;
 }
 /**
  * State store implementation using Cloudflare R2 API
@@ -34,12 +22,10 @@ export interface CloudflareR2StateStoreOptions {
  */
 export declare class R2RestStateStore implements StateStore {
     readonly scope: Scope;
+    private readonly options;
     private api;
     private prefix;
     private bucketName;
-    private apiKey;
-    private accountId;
-    private email;
     private initialized;
     /**
      * Create a new CloudflareR2StateStore

package/lib/cloudflare/r2-rest-state-store.js

@@ -1,18 +1,16 @@
 import { deserialize, serialize } from "../serde";
 import { withExponentialBackoff } from "../util/retry";
-import { createCloudflareApi } from "./api";
+import { createCloudflareApi, } from "./api";
 /**
  * State store implementation using Cloudflare R2 API
  * Uses R2 for immediate consistency compared to KV's eventual consistency
  */
 export class R2RestStateStore {
     scope;
+    options;
     api;
     prefix;
     bucketName;
-    apiKey;
-    accountId;
-    email;
     initialized = false;
     /**
      * Create a new CloudflareR2StateStore
@@ -22,6 +20,7 @@ export class R2RestStateStore {
      */
     constructor(scope, options) {
         this.scope = scope;
+        this.options = options;
         // Use the scope's chain to build the prefix, similar to how FileSystemStateStore builds its directory
         const scopePath = scope.chain.join("/");
         this.prefix = options.prefix
@@ -31,9 +30,6 @@ export class R2RestStateStore {
             throw new Error("bucketName is required for CloudflareR2StateStore");
         }
         this.bucketName = options.bucketName;
-        this.apiKey = options.apiKey;
-        this.accountId = options.accountId;
-        this.email = options.email;
         // We'll initialize the API in init() to allow for async creation
         this.api = null;
     }
@@ -44,11 +40,7 @@ export class R2RestStateStore {
         if (this.initialized)
             return;
         // Create Cloudflare API client with automatic account discovery
-        this.api = await createCloudflareApi({
-            apiKey: this.apiKey,
-            accountId: this.accountId,
-            email: this.email,
-        });
+        this.api = await createCloudflareApi(this.options);
         this.initialized = true;
     }
     /**

package/lib/cloudflare/worker.d.ts

@@ -1,13 +1,14 @@
 import type { Context } from "../context";
 import { type BundleProps } from "../esbuild/bundle";
 import { Resource } from "../resource";
+import { type CloudflareApiOptions } from "./api";
 import { type Bindings } from "./bindings";
 import type { Bound } from "./bound";
 import type { SingleStepMigration } from "./worker-migration";
 /**
  * Properties for creating or updating a Worker
  */
-export interface WorkerProps<B extends Bindings = Bindings> {
+export interface WorkerProps<B extends Bindings = Bindings> extends CloudflareApiOptions {
     /**
      * The worker script content (JavaScript or WASM)
      * One of script, entryPoint, or bundle must be provided
@@ -36,11 +37,6 @@ export interface WorkerProps<B extends Bindings = Bindings> {
      * This is mandatory - must be explicitly specified
      */
     name: string;
-    /**
-     * Routes to associate with this worker
-     * Format: example.com/* or *.example.com/*
-     */
-    routes?: string[];
     /**
      * Bindings to attach to the worker
      */

package/lib/cloudflare/worker.js

@@ -2,13 +2,15 @@ import * as crypto from "crypto";
 import * as fs from "fs/promises";
 import { Bundle } from "../esbuild/bundle";
 import { Resource } from "../resource";
-import { isSecret } from "../secret";
 import { getContentType } from "../util/content-type";
 import { withExponentialBackoff } from "../util/retry";
 import { slugify } from "../util/slugify";
-import { createCloudflareApi } from "./api";
-import { isAssets, isDurableObjectNamespace, } from "./bindings";
+import { createCloudflareApi, } from "./api";
+import {} from "./assets";
+import {} from "./bindings";
+import {} from "./durable-object-namespace";
 import { isKVNamespace } from "./kv-namespace";
+import { upsertWorkflow } from "./workflow";
 /**
  * A Cloudflare Worker is a serverless function that can be deployed to the Cloudflare network.
  *
@@ -90,7 +92,7 @@ export const Worker = Resource("cloudflare::Worker", {
     alwaysUpdate: true,
 }, async function (id, props) {
     // Create Cloudflare API client with automatic account discovery
-    const api = await createCloudflareApi();
+    const api = await createCloudflareApi(props);
     // Use the provided name
     const workerName = props.name;
     // Validate input - we need either script, entryPoint, or bundle
@@ -111,10 +113,16 @@ export const Worker = Resource("cloudflare::Worker", {
     const scriptContent = props.script ?? (await bundleWorkerScript(props));
     // Find any assets bindings
     const assetsBindings = [];
+    const workflowsBindings = [];
     if (props.bindings) {
         for (const [bindingName, binding] of Object.entries(props.bindings)) {
-            if (isAssets(binding)) {
-                assetsBindings.push({ name: bindingName, assets: binding });
+            if (typeof binding === "object") {
+                if (binding.type === "assets") {
+                    assetsBindings.push({ name: bindingName, assets: binding });
+                }
+                else if (binding.type === "workflow") {
+                    workflowsBindings.push(binding);
+                }
             }
         }
     }
@@ -129,12 +137,16 @@ export const Worker = Resource("cloudflare::Worker", {
     }
     // Prepare metadata with bindings
     const scriptMetadata = await prepareWorkerMetadata(this, oldBindings, props, assetUploadResult);
-    // Upload the worker script
     await putWorker(api, workerName, scriptContent, scriptMetadata);
+    for (const workflow of workflowsBindings) {
+        await upsertWorkflow(api, {
+            workflowName: workflow.workflowName,
+            className: workflow.className,
+            scriptName: workerName,
+        });
+    }
     // TODO: it is less than ideal that this can fail, resulting in state problem
     await this.set("bindings", props.bindings);
-    // Handle routes if requested
-    await setupRoutes(api, workerName, props.routes || []);
     // Handle worker URL if requested
     const workerUrl = await configureURL(this, api, workerName, props.url ?? false);
     // Get current timestamp
@@ -146,7 +158,6 @@ export const Worker = Resource("cloudflare::Worker", {
         name: workerName,
         script: scriptContent,
         format: props.format || "esm", // Include format in the output
-        routes: props.routes || [],
         bindings: props.bindings ?? {},
         env: props.env,
         observability: scriptMetadata.observability,
@@ -167,25 +178,6 @@ async function deleteWorker(ctx, api, workerName) {
             .catch(() => ({ errors: [{ message: deleteResponse.statusText }] }));
         console.error("Error deleting worker:", errorData.errors?.[0]?.message || deleteResponse.statusText);
     }
-    // Also remove any associated routes if they exist
-    if (ctx.output?.routes && ctx.output.routes.length > 0 && api.zoneId) {
-        // First get existing routes to find their IDs
-        const routesResponse = await api.get(`/zones/${api.zoneId}/workers/routes`);
-        if (!routesResponse.ok) {
-            throw new Error(`Could not fetch routes for cleanup: ${routesResponse.status} ${routesResponse.statusText}`);
-        }
-        const routesData = await routesResponse.json();
-        const existingRoutes = routesData.result || [];
-        for (const route of existingRoutes) {
-            if (ctx.output.routes.includes(route.pattern)) {
-                // Delete the route
-                const routeDeleteResponse = await api.delete(`/zones/${api.zoneId}/workers/routes/${route.id}`);
-                if (!routeDeleteResponse.ok) {
-                    console.warn(`Failed to delete route ${route.pattern}: ${routeDeleteResponse.status} ${routeDeleteResponse.statusText}`);
-                }
-            }
-        }
-    }
     // Disable the URL if it was enabled
     if (ctx.output?.url) {
         try {
@@ -295,33 +287,15 @@ async function prepareWorkerMetadata(ctx, oldBindings, props, assetUploadResult)
             });
         }
         else if (binding.type === "durable_object_namespace") {
-            const stableId = binding.id;
-            const className = binding.className;
             meta.bindings.push({
                 type: "durable_object_namespace",
                 name: bindingName,
-                class_name: className,
+                class_name: binding.className,
                 script_name: binding.scriptName,
                 environment: binding.environment,
                 namespace_id: binding.namespaceId,
             });
-            const oldBinding = Object.values(oldBindings ?? {})
-                ?.filter(isDurableObjectNamespace)
-                ?.find((b) => b.id === stableId);
-            if (!oldBinding) {
-                if (binding.sqlite) {
-                    meta.migrations.new_sqlite_classes.push(className);
-                }
-                else {
-                    meta.migrations.new_classes.push(className);
-                }
-            }
-            else if (oldBinding.className !== className) {
-                meta.migrations.renamed_classes.push({
-                    from: oldBinding.className,
-                    to: className,
-                });
-            }
+            configureClassMigration(binding, binding.id, binding.className);
         }
         else if (binding.type === "r2_bucket") {
             meta.bindings.push({
@@ -330,25 +304,58 @@ async function prepareWorkerMetadata(ctx, oldBindings, props, assetUploadResult)
                 bucket_name: binding.name,
             });
         }
-        else if (isAssets(binding)) {
+        else if (binding.type === "assets") {
             meta.bindings.push({
                 type: "assets",
                 name: bindingName,
             });
         }
-        else if (isSecret(binding)) {
+        else if (binding.type === "secret") {
             meta.bindings.push({
                 type: "secret_text",
                 name: bindingName,
                 text: binding.unencrypted,
             });
         }
+        else if (binding.type === "workflow") {
+            meta.bindings.push({
+                type: "workflow",
+                name: bindingName,
+                workflow_name: binding.workflowName,
+                class_name: binding.className,
+                // this should be set if the Workflow is in another script ...
+                // script_name: ??,
+            });
+            // it's unclear whether this is needed, but it works both ways
+            configureClassMigration(binding, binding.id, binding.className);
+        }
         else {
             // @ts-expect-error - we should never reach here
             throw new Error(`Unsupported binding type: ${binding.type}`);
         }
     }
+    function configureClassMigration(binding, stableId, className) {
+        const oldBinding = Object.values(oldBindings ?? {})
+            ?.filter((b) => typeof b === "object" &&
+            (b.type === "durable_object_namespace" || b.type === "workflow"))
+            ?.find((b) => b.id === stableId);
+        if (!oldBinding) {
+            if (binding.type === "durable_object_namespace" && binding.sqlite) {
+                meta.migrations.new_sqlite_classes.push(className);
+            }
+            else {
+                meta.migrations.new_classes.push(className);
+            }
+        }
+        else if (oldBinding.className !== className) {
+            meta.migrations.renamed_classes.push({
+                from: oldBinding.className,
+                to: className,
+            });
+        }
+    }
     // Convert env variables to plain_text bindings
+    // TODO(sam): remove Worker.env in favor of always bindings
     if (props.env) {
         for (const [key, value] of Object.entries(props.env)) {
             meta.bindings.push({
@@ -421,44 +428,6 @@ async function bundleWorkerScript(props) {
         throw new Error("Error reading bundle");
     }
 }
-async function setupRoutes(api, workerName, routes) {
-    // Set up routes if provided
-    if (routes && routes.length > 0 && api.zoneId) {
-        // First get existing routes
-        const routesResponse = await api.get(`/zones/${api.zoneId}/workers/routes`);
-        if (!routesResponse.ok) {
-            throw new Error(`Could not fetch routes: ${routesResponse.status} ${routesResponse.statusText}`);
-        }
-        const routesData = await routesResponse.json();
-        const existingRoutes = routesData.result || [];
-        // For each desired route
-        for (const pattern of routes) {
-            const existingRoute = existingRoutes.find((r) => r.pattern === pattern);
-            if (existingRoute) {
-                // Update if script name doesn't match
-                if (existingRoute.script !== workerName) {
-                    const updateRouteResponse = await api.put(`/zones/${api.zoneId}/workers/routes/${existingRoute.id}`, {
-                        pattern,
-                        script: workerName,
-                    });
-                    if (!updateRouteResponse.ok) {
-                        console.warn(`Failed to update route ${pattern}: ${updateRouteResponse.status} ${updateRouteResponse.statusText}`);
-                    }
-                }
-            }
-            else {
-                // Create new route
-                const createRouteResponse = await api.post(`/zones/${api.zoneId}/workers/routes`, {
-                    pattern,
-                    script: workerName,
-                });
-                if (!createRouteResponse.ok) {
-                    throw new Error(`Failed to create route ${pattern}: ${createRouteResponse.status} ${createRouteResponse.statusText}`);
-                }
-            }
-        }
-    }
-}
 async function configureURL(ctx, api, workerName, url) {
     let workerUrl;
     if (url) {
@@ -579,7 +548,6 @@ async function uploadAssets(api, workerName, assets) {
             totalBytes += blob.size;
             formData.append(fileHash, blob, fileHash);
         }
-        console.log(`Uploading ${totalBytes} bytes of assets`);
         // Upload this batch of files
         const uploadResponse = await api.post(`/accounts/${api.accountId}/workers/assets/upload?base64=true`, formData, {
             headers: {

package/lib/cloudflare/workflow.d.ts

@@ -0,0 +1,46 @@
+import type { CloudflareApi } from "./api";
+export interface WorkflowProps {
+    /**
+     * Name of the workflow
+     *
+     * @maxLength 64
+     * @minLength 1
+     * @default - className if provided, otherwise id
+     */
+    workflowName?: string;
+    /**
+     * Name of the class that implements the workflow
+     *
+     * @maxLength 255
+     * @minLength 1
+     * @default - workflowName if provided, otherwise id
+     */
+    className?: string;
+}
+export declare class Workflow<PARAMS = unknown> {
+    readonly id: string;
+    readonly type: "workflow";
+    /**
+     * Phantom property to preserve workflow params at the type level.
+     *
+     * No value exists.
+     */
+    readonly _PARAMS: PARAMS;
+    readonly workflowName: string;
+    readonly className: string;
+    constructor(id: string, props?: WorkflowProps);
+}
+export interface WorkflowMetadata {
+    id: string;
+    class_name: string;
+    created_on: string;
+    modified_on: string;
+    name: string;
+    script_name: string;
+    triggered_on: string;
+    version_id: string;
+}
+export declare function upsertWorkflow(api: CloudflareApi, props: WorkflowProps & {
+    workflowName: string;
+    scriptName: string;
+}): Promise<WorkflowMetadata>;

package/lib/cloudflare/workflow.js

@@ -0,0 +1,29 @@
+import { handleApiError } from "./api-error";
+export class Workflow {
+    id;
+    type = "workflow";
+    /**
+     * Phantom property to preserve workflow params at the type level.
+     *
+     * No value exists.
+     */
+    _PARAMS = undefined;
+    workflowName;
+    className;
+    constructor(id, props = {}) {
+        this.id = id;
+        this.workflowName = props.workflowName ?? props.className ?? id;
+        this.className = props.className ?? this.workflowName;
+    }
+}
+export async function upsertWorkflow(api, props) {
+    const response = await api.put(`/accounts/${api.accountId}/workflows/${props.workflowName}`, {
+        class_name: props.className,
+        script_name: props.scriptName,
+    });
+    if (!response.ok) {
+        await handleApiError(response, "create", "workflow", props.workflowName);
+    }
+    const body = (await response.json());
+    return body.result;
+}

package/lib/cloudflare/zone.d.ts

@@ -1,19 +1,15 @@
 import type { Context } from "../context";
 import { Resource } from "../resource";
+import { type CloudflareApiOptions } from "./api";
 import type { AlwaysUseHTTPSValue, AutomaticHTTPSRewritesValue, BrotliValue, DevelopmentModeValue, EarlyHintsValue, EmailObfuscationValue, HTTP2Value, HTTP3Value, HotlinkProtectionValue, IPv6Value, MinTLSVersionValue, SSLValue, TLS13Value, WebSocketsValue, ZeroRTTValue } from "./zone-settings";
 /**
  * Properties for creating or updating a Zone
  */
-export interface ZoneProps {
+export interface ZoneProps extends CloudflareApiOptions {
     /**
      * The domain name for the zone
      */
     name: string;
-    /**
-     * Account ID to use for the zone
-     * If not provided, will use the default account
-     */
-    accountId?: string;
     /**
      * The type of zone to create
      * "full" - Full zone implies that DNS is hosted with Cloudflare