alchemy 0.5.2 → 0.7.0

package/src/cloudflare/dns-records.ts

@@ -5,7 +5,11 @@ import type {
   DnsRecordWithMetadata,
 } from "../dns/record";
 import { Resource } from "../resource";
-import { type CloudflareApi, createCloudflareApi } from "./api";
+import {
+  type CloudflareApi,
+  type CloudflareApiOptions,
+  createCloudflareApi,
+} from "./api";
 import type { CloudflareResponse } from "./response";
 
 /**
@@ -48,7 +52,7 @@ export interface DnsRecord extends DnsRecordWithMetadata {}
 /**
  * Properties for managing multiple DNS records
  */
-export interface DnsRecordsProps {
+export interface DnsRecordsProps extends CloudflareApiOptions {
   /**
    * Zone ID or domain name where records will be created
    */
@@ -127,7 +131,7 @@ export const DnsRecords = Resource(
     props: DnsRecordsProps
   ): Promise<DnsRecords> {
     // Create Cloudflare API client
-    const api = await createCloudflareApi();
+    const api = await createCloudflareApi(props);
 
     // Get zone ID if domain name was provided
     const zoneId = props.zoneId;

package/src/cloudflare/durable-object-namespace.ts

@@ -42,7 +42,7 @@ export class DurableObjectNamespace implements DurableObjectNamespaceInput {
 
   constructor(
     public readonly id: string,
-    input: DurableObjectNamespaceInput,
+    input: DurableObjectNamespaceInput
   ) {
     this.className = input.className;
     this.scriptName = input.scriptName;

package/src/cloudflare/index.ts

@@ -10,5 +10,6 @@ export * from "./kv-namespace";
 export * from "./permission-groups";
 export * from "./r2-rest-state-store";
 export * from "./worker";
+export { Workflow } from "./workflow";
 export * from "./wrangler.json";
 export * from "./zone";

package/src/cloudflare/kv-namespace.ts

@@ -1,7 +1,12 @@
 import type { Context } from "../context";
 import { Resource } from "../resource";
 import { withExponentialBackoff } from "../util/retry";
-import { createCloudflareApi } from "./api";
+import {
+  CloudflareApi,
+  createCloudflareApi,
+  type CloudflareApiOptions,
+} from "./api";
+import { handleApiError } from "./api-error";
 
 export function isKVNamespace(resource: any): resource is KVNamespace {
   return (
@@ -12,7 +17,7 @@ export function isKVNamespace(resource: any): resource is KVNamespace {
 /**
  * Properties for creating or updating a KV Namespace
  */
-export interface KVNamespaceProps {
+export interface KVNamespaceProps extends CloudflareApiOptions {
   /**
    * Title of the namespace
    */
@@ -119,28 +124,16 @@ export const KVNamespace = Resource(
   async function (
     this: Context<KVNamespace>,
     id: string,
-    props: KVNamespaceProps,
+    props: KVNamespaceProps
   ) {
     // 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: any = 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
@@ -159,96 +152,12 @@ export const KVNamespace = Resource(
         // Can't update a KV namespace title directly, just work with existing ID
       } 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: any = 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: any = 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: any = {
-              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: any = 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: any) {
-            console.warn(error.message);
-          }
-        }
-      }
+      await insertKVRecords(api, namespaceId, props);
 
       return this({
         type: "kv_namespace",
@@ -259,5 +168,108 @@ export const KVNamespace = Resource(
         modifiedAt: Date.now(),
       });
     }
-  },
+  }
 );
+
+export async function createKVNamespace(
+  api: CloudflareApi,
+  props: KVNamespaceProps
+): Promise<{ id: string }> {
+  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()) as any).result.id };
+}
+
+export async function deleteKVNamespace(
+  api: CloudflareApi,
+  namespaceId: string
+) {
+  // 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: CloudflareApi,
+  namespaceId: string,
+  props: KVNamespaceProps
+) {
+  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: any = {
+          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: any = 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: any) {
+        console.warn(error.message);
+      }
+    }
+  }
+}

package/src/cloudflare/permission-groups.ts

@@ -72,6 +72,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");
@@ -99,7 +103,7 @@ export const PermissionGroups = Resource(
   async function (
     this: Context<PermissionGroups>,
     id: string,
-    options?: CloudflareApiOptions
+    options: CloudflareApiOptions = {}
   ): Promise<PermissionGroups> {
     // Only create and update phases are supported
     if (this.phase === "delete") {

package/src/cloudflare/r2-rest-state-store.ts

@@ -1,14 +1,17 @@
 import type { Scope } from "../scope";
-import type { Secret } from "../secret";
 import { deserialize, serialize } from "../serde";
 import type { State, StateStore } from "../state";
 import { withExponentialBackoff } from "../util/retry";
-import { type CloudflareApi, createCloudflareApi } from "./api";
+import {
+  type CloudflareApi,
+  type CloudflareApiOptions,
+  createCloudflareApi,
+} 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
@@ -20,21 +23,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;
 }
 
 /**
@@ -45,9 +33,6 @@ export class R2RestStateStore implements StateStore {
   private api: CloudflareApi;
   private prefix: string;
   private bucketName: string;
-  private apiKey: Secret | undefined;
-  private accountId: string | undefined;
-  private email: string | undefined;
   private initialized = false;
 
   /**
@@ -58,7 +43,7 @@ export class R2RestStateStore implements StateStore {
    */
   constructor(
     public readonly scope: Scope,
-    options: CloudflareR2StateStoreOptions
+    private readonly options: CloudflareR2StateStoreOptions
   ) {
     // Use the scope's chain to build the prefix, similar to how FileSystemStateStore builds its directory
     const scopePath = scope.chain.join("/");
@@ -71,10 +56,6 @@ export class R2RestStateStore implements StateStore {
     }
     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 as any;
   }
@@ -86,11 +67,7 @@ export class R2RestStateStore implements StateStore {
     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;
   }