alchemy 0.3.1 → 0.4.1

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

@@ -1,7 +1,8 @@
 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 { deserialize, serialize } from "../util/serde";
 import { type CloudflareApi, createCloudflareApi } from "./api";
 
 /**
@@ -23,7 +24,7 @@ export interface CloudflareR2StateStoreOptions {
   /**
    * API key to use (overrides CLOUDFLARE_API_KEY env var)
    */
-  apiKey?: string;
+  apiKey?: Secret;
 
   /**
    * Account ID to use (overrides CLOUDFLARE_ACCOUNT_ID env var)
@@ -44,7 +45,7 @@ export class R2RestStateStore implements StateStore {
   private api: CloudflareApi;
   private prefix: string;
   private bucketName: string;
-  private apiKey: string | undefined;
+  private apiKey: Secret | undefined;
   private accountId: string | undefined;
   private email: string | undefined;
   private initialized = false;
@@ -57,7 +58,7 @@ export class R2RestStateStore implements StateStore {
    */
   constructor(
     public readonly scope: Scope,
-    options: CloudflareR2StateStoreOptions,
+    options: CloudflareR2StateStoreOptions
   ) {
     // Use the scope's chain to build the prefix, similar to how FileSystemStateStore builds its directory
     const scopePath = scope.chain.join("/");
@@ -122,16 +123,30 @@ export class R2RestStateStore implements StateStore {
       }
 
       const listPath = `/accounts/${this.api.accountId}/r2/buckets/${this.bucketName}/objects?${params.toString()}`;
-      const response = await this.api.get(listPath);
-
-      if (!response.ok) {
-        const errorData: any = await response.json().catch(() => ({
-          errors: [{ message: response.statusText }],
-        }));
-        throw new Error(
-          `Error listing R2 objects: ${errorData.errors?.[0]?.message || response.statusText}`,
-        );
-      }
+
+      const response = await withExponentialBackoff(
+        async () => {
+          const response = await this.api.get(listPath);
+
+          if (!response.ok) {
+            const errorData: any = await response.json().catch(() => ({
+              errors: [{ message: response.statusText }],
+            }));
+            throw new Error(
+              `Error listing R2 objects: ${errorData.errors?.[0]?.message || response.statusText}`
+            );
+          }
+
+          return response;
+        },
+        // Retry on transient errors
+        (error) =>
+          error.message?.includes("502") ||
+          error.message?.includes("503") ||
+          error.message?.includes("timeout"),
+        5, // 5 retry attempts
+        1000 // Start with 1 second delay
+      );
 
       const data = (await response.json()) as any;
 
@@ -144,7 +159,7 @@ export class R2RestStateStore implements StateStore {
         objects.map((obj: any) => {
           const keyName = obj.key || obj.name;
           return this.convertKeyFromStorage(keyName.slice(this.prefix.length));
-        }),
+        })
       );
 
       // Update cursor for next page if available
@@ -175,21 +190,38 @@ export class R2RestStateStore implements StateStore {
     await this.ensureInitialized();
 
     try {
-      const response = await this.api.get(
-        `/accounts/${this.api.accountId}/r2/buckets/${this.bucketName}/objects/${this.getObjectKey(key)}`,
-      );
+      const response = await withExponentialBackoff(
+        async () => {
+          const response = await this.api.get(
+            `/accounts/${this.api.accountId}/r2/buckets/${this.bucketName}/objects/${this.getObjectKey(key)}`
+          );
 
-      if (!response.ok) {
-        if (response.status === 404) {
-          return undefined;
-        }
+          if (!response.ok) {
+            if (response.status === 404) {
+              return response;
+            }
 
-        const errorData: any = await response.json().catch(() => ({
-          errors: [{ message: response.statusText }],
-        }));
-        throw new Error(
-          `Error getting R2 object: ${errorData.errors?.[0]?.message || response.statusText}`,
-        );
+            const errorData: any = await response.json().catch(() => ({
+              errors: [{ message: response.statusText }],
+            }));
+            throw new Error(
+              `Error getting R2 object: ${errorData.errors?.[0]?.message || response.statusText}`
+            );
+          }
+
+          return response;
+        },
+        // Retry on transient errors
+        (error) =>
+          error.message?.includes("502") ||
+          error.message?.includes("503") ||
+          error.message?.includes("timeout"),
+        5, // 5 retry attempts
+        1000 // Start with 1 second delay
+      );
+
+      if (response.status === 404) {
+        return undefined;
       }
 
       // Parse and deserialize the state data
@@ -267,7 +299,7 @@ export class R2RestStateStore implements StateStore {
             headers: {
               "Content-Type": "application/json",
             },
-          },
+          }
         );
 
         if (!response.ok) {
@@ -275,7 +307,7 @@ export class R2RestStateStore implements StateStore {
             errors: [{ message: response.statusText }],
           }));
           throw new Error(
-            `Error writing to R2: ${errorData.errors?.[0]?.message || response.statusText}`,
+            `Error writing to R2: ${errorData.errors?.[0]?.message || response.statusText}`
           );
         }
 
@@ -285,7 +317,7 @@ export class R2RestStateStore implements StateStore {
       (error) =>
         error.message?.includes("503") || error.message?.includes("timeout"),
       5, // 5 retry attempts
-      1000, // Start with 1 second delay
+      1000 // Start with 1 second delay
     );
   }
 
@@ -297,18 +329,31 @@ export class R2RestStateStore implements StateStore {
   async delete(key: string): Promise<void> {
     await this.ensureInitialized();
 
-    const response = await this.api.delete(
-      `/accounts/${this.api.accountId}/r2/buckets/${this.bucketName}/objects/${this.getObjectKey(key)}`,
-    );
+    await withExponentialBackoff(
+      async () => {
+        const response = await this.api.delete(
+          `/accounts/${this.api.accountId}/r2/buckets/${this.bucketName}/objects/${this.getObjectKey(key)}`
+        );
 
-    if (!response.ok && response.status !== 404) {
-      const errorData: any = await response.json().catch(() => ({
-        errors: [{ message: response.statusText }],
-      }));
-      throw new Error(
-        `Error deleting from R2: ${errorData.errors?.[0]?.message || response.statusText}`,
-      );
-    }
+        if (!response.ok && response.status !== 404) {
+          const errorData: any = await response.json().catch(() => ({
+            errors: [{ message: response.statusText }],
+          }));
+          throw new Error(
+            `Error deleting from R2: ${errorData.errors?.[0]?.message || response.statusText}`
+          );
+        }
+
+        return response;
+      },
+      // Retry on transient errors
+      (error) =>
+        error.message?.includes("502") ||
+        error.message?.includes("503") ||
+        error.message?.includes("timeout"),
+      5, // 5 retry attempts
+      1000 // Start with 1 second delay
+    );
   }
 
   /**

package/src/cloudflare/static-site.ts

@@ -96,16 +96,6 @@ export interface StaticSiteProps {
    */
   production?: boolean;
 
-  /**
-   * Custom domain for the site
-   */
-  domain?:
-    | string
-    | {
-        name: string;
-        redirects?: string[];
-      };
-
   build?: {
     /**
      * Command to run before deploying the site
@@ -176,16 +166,6 @@ export interface StaticSite extends Resource<"cloudflare::StaticSite"> {
    */
   assets: string[];
 
-  /**
-   * Custom domain for the site
-   */
-  domain?:
-    | string
-    | {
-        name: string;
-        redirects?: string[];
-      };
-
   /**
    * Whether the site is deployed to production
    */
@@ -243,13 +223,26 @@ export interface StaticSite extends Resource<"cloudflare::StaticSite"> {
  * });
  *
  * @example
- * // Create a static site with custom error page and index
- * const customSite = await StaticSite("custom-site", {
+ * // Create a static site with a custom domain using the CustomDomain resource
+ * const site = await StaticSite("custom-site", {
  *   name: "custom-site",
  *   dir: "./www",
  *   errorPage: "404.html",
- *   indexPage: "home.html",
- *   domain: "www.example.com"
+ *   indexPage: "home.html"
+ * });
+ *
+ * // Then configure the custom domain separately
+ * const domain = await CustomDomain("custom-domain", {
+ *   name: "www.example.com",
+ *   zoneId: "abcdef123456789",
+ *   workerName: site.name
+ * });
+ *
+ * @example
+ * // Create a static site with multiple domains (primary + redirects)
+ * const site = await StaticSite("multi-domain-site", {
+ *   name: "multi-domain-site",
+ *   dir: "./public"
  * });
  *
  * @see https://developers.cloudflare.com/workers/platform/sites
@@ -264,6 +257,9 @@ export const StaticSite = Resource(
     id: string,
     props: StaticSiteProps
   ) {
+    // Create Cloudflare API client with automatic account discovery
+    const api = await createCloudflareApi();
+
     if (this.phase === "delete") {
       // For delete operations, we'll rely on the Worker delete to clean up
       // Return empty output for deleted state
@@ -322,9 +318,6 @@ export const StaticSite = Resource(
     const siteName = props.name;
     const indexPage = props.indexPage || "index.html";
 
-    // Create Cloudflare API client with automatic account discovery
-    const api = await createCloudflareApi();
-
     // Step 1: Create or get the KV namespace for assets
     const [kv, assetManifest] = await Promise.all([
       KVNamespace("assets", {
@@ -333,10 +326,6 @@ export const StaticSite = Resource(
       generateAssetManifest(props.dir),
     ]);
 
-    console.log({
-      assetManifest,
-    });
-
     // Step 3: Upload assets to KV
     await uploadAssetManifest(api, kv.namespaceId, assetManifest);
 
@@ -419,7 +408,6 @@ export const StaticSite = Resource(
       assets: assetManifest.map((item) => item.key),
       createdAt: this.output?.createdAt || now,
       updatedAt: now,
-      domain: props.domain,
       production: props.production !== false,
       url: worker.url,
       routes,

package/src/cloudflare/worker.ts

@@ -1,14 +1,18 @@
+import * as crypto from "crypto";
 import * as fs from "fs/promises";
 import type { Context } from "../context";
 import { Bundle, type BundleProps } 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 { type CloudflareApi, createCloudflareApi } from "./api";
+import type { Assets } from "./assets";
 import {
   type Bindings,
   type WorkerBindingSpec,
+  isAssets,
   isDurableObjectNamespace,
 } from "./bindings";
 import type { Bound } from "./bound";
@@ -200,6 +204,20 @@ export interface Worker<B extends Bindings = Bindings>
  *   }
  * });
  *
+ * @example
+ * // Create a worker with static assets:
+ * const staticAssets = await Assets("static", {
+ *   path: "./src/assets"
+ * });
+ *
+ * const frontendWorker = await Worker("frontend", {
+ *   name: "frontend-worker",
+ *   entrypoint: "./src/worker.ts",
+ *   bindings: {
+ *     ASSETS: staticAssets
+ *   }
+ * });
+ *
  * @see https://developers.cloudflare.com/workers/
  */
 export const Worker = Resource(
@@ -232,15 +250,42 @@ export const Worker = Resource(
 
     const oldBindings = await this.get<Bindings>("bindings");
 
+    // Get the script content - either from props.script, or by bundling
+    const scriptContent = props.script ?? (await bundleWorkerScript(props));
+
+    // Find any assets bindings
+    const assetsBindings: { name: string; assets: Assets }[] = [];
+    if (props.bindings) {
+      for (const [bindingName, binding] of Object.entries(props.bindings)) {
+        if (isAssets(binding)) {
+          assetsBindings.push({ name: bindingName, assets: binding });
+        }
+      }
+    }
+
+    // Upload any assets and get completion tokens
+    let assetUploadResult: AssetUploadResult | undefined;
+    if (assetsBindings.length > 0) {
+      // We'll use the first asset binding for now
+      // In the future, we might want to support multiple asset bindings
+      const assetBinding = assetsBindings[0];
+
+      // Upload the assets and get the completion token
+      assetUploadResult = await uploadAssets(
+        api,
+        workerName,
+        assetBinding.assets
+      );
+    }
+
+    // Prepare metadata with bindings
     const scriptMetadata = await prepareWorkerMetadata(
       this,
       oldBindings,
-      props
+      props,
+      assetUploadResult
     );
 
-    // Get the script content - either from props.script, or by bundling
-    const scriptContent = props.script ?? (await bundleWorkerScript(props));
-
     // Upload the worker script
     await putWorker(api, workerName, scriptContent, scriptMetadata);
 
@@ -437,12 +482,29 @@ interface WorkerMetadata {
   main_module?: string;
   body_part?: string;
   tags?: string[];
+  assets?: {
+    jwt?: string;
+    keep_assets?: boolean;
+    config?: {
+      html_handling?: "auto-trailing-slash" | "none";
+      not_found_handling?: "none" | "fall-through";
+    };
+  };
+}
+
+interface AssetUploadResult {
+  completionToken: string;
+  assetConfig?: {
+    html_handling?: "auto-trailing-slash" | "none";
+    not_found_handling?: "none" | "fall-through";
+  };
 }
 
 async function prepareWorkerMetadata<B extends Bindings>(
   ctx: Context<Worker<B>>,
   oldBindings: Bindings | undefined,
-  props: WorkerProps
+  props: WorkerProps,
+  assetUploadResult?: AssetUploadResult
 ): Promise<WorkerMetadata> {
   // Prepare metadata with bindings
   const meta: WorkerMetadata = {
@@ -461,6 +523,17 @@ async function prepareWorkerMetadata<B extends Bindings>(
     },
   };
 
+  // If we have asset upload results, add them to the metadata
+  if (assetUploadResult) {
+    meta.assets = {
+      jwt: assetUploadResult.completionToken,
+    };
+
+    if (assetUploadResult.assetConfig) {
+      meta.assets.config = assetUploadResult.assetConfig;
+    }
+  }
+
   const bindings = (props.bindings ?? {}) as Bindings;
 
   // Convert bindings to the format expected by the API
@@ -522,6 +595,11 @@ async function prepareWorkerMetadata<B extends Bindings>(
         name: bindingName,
         bucket_name: binding.name,
       });
+    } else if (isAssets(binding)) {
+      meta.bindings.push({
+        type: "assets",
+        name: bindingName,
+      });
     } else if (isSecret(binding)) {
       meta.bindings.push({
         type: "secret_text",
@@ -802,3 +880,173 @@ async function getWorkerBindings(
 
   return data.result;
 }
+
+/**
+ * Interface for a file's metadata to be uploaded
+ */
+interface FileMetadata {
+  hash: string;
+  size: number;
+}
+
+/**
+ * Response from the assets upload session API
+ */
+interface UploadSessionResponse {
+  result: {
+    jwt: string;
+    buckets: string[][];
+  };
+  success: boolean;
+  errors: any[];
+  messages: any[];
+}
+
+/**
+ * Response from the file upload API
+ */
+interface UploadResponse {
+  result: {
+    jwt: string;
+    buckets?: string[][];
+  };
+  success: boolean;
+  errors: any[];
+  messages: any[];
+}
+
+/**
+ * Uploads assets to Cloudflare and returns a completion token
+ *
+ * @param api CloudflareApi instance
+ * @param workerName Name of the worker
+ * @param assets Assets resource containing files to upload
+ * @returns Completion token for the assets upload
+ */
+async function uploadAssets(
+  api: CloudflareApi,
+  workerName: string,
+  assets: Assets
+): Promise<AssetUploadResult> {
+  // Generate the file manifest
+  const fileMetadata: Record<string, FileMetadata> = {};
+
+  // Process each file in the assets
+  for (const file of assets.files) {
+    const { hash, size } = await calculateFileMetadata(file.filePath);
+    // Use the relative path as the key, ensuring it starts with a slash
+    const key = file.path.startsWith("/") ? file.path : `/${file.path}`;
+    fileMetadata[key] = { hash, size };
+  }
+
+  // Start the upload session
+  const uploadSessionUrl = `/accounts/${api.accountId}/workers/scripts/${workerName}/assets-upload-session`;
+  const uploadSessionResponse = await api.post(
+    uploadSessionUrl,
+    JSON.stringify({ manifest: fileMetadata }),
+    {
+      headers: { "Content-Type": "application/json" },
+    }
+  );
+
+  if (!uploadSessionResponse.ok) {
+    throw new Error(
+      `Failed to start assets upload session: ${uploadSessionResponse.status} ${uploadSessionResponse.statusText}`
+    );
+  }
+
+  const sessionData =
+    (await uploadSessionResponse.json()) as UploadSessionResponse;
+
+  // If there are no buckets, assets are already uploaded or empty
+  if (!sessionData.result.buckets || sessionData.result.buckets.length === 0) {
+    return { completionToken: sessionData.result.jwt };
+  }
+
+  // Upload the files in batches as specified by the API
+  let completionToken = sessionData.result.jwt;
+  const buckets = sessionData.result.buckets;
+
+  // Process each bucket of files
+  for (const bucket of buckets) {
+    const formData = new FormData();
+
+    // Add each file in the bucket to the form
+    for (const fileHash of bucket) {
+      // Find the file with this hash
+      const file = assets.files.find((f) => {
+        const filePath = f.path.startsWith("/") ? f.path : `/${f.path}`;
+        return fileMetadata[filePath]?.hash === fileHash;
+      });
+
+      if (!file) {
+        throw new Error(`Could not find file with hash ${fileHash}`);
+      }
+
+      // Read the file content
+      const fileContent = await fs.readFile(file.filePath);
+
+      // Convert to base64 as required by the API when using base64=true
+      const base64Content = fileContent.toString("base64");
+
+      // Add the file to the form with the hash as the key and set the correct content type
+      const blob = new Blob([base64Content], {
+        type: getContentType(file.filePath),
+      });
+      formData.append(fileHash, blob, fileHash);
+    }
+
+    // Upload this batch of files
+    const uploadResponse = await api.post(
+      `/accounts/${api.accountId}/workers/assets/upload?base64=true`,
+      formData,
+      {
+        headers: {
+          Authorization: `Bearer ${completionToken}`,
+          "Content-Type": "multipart/form-data",
+        },
+      }
+    );
+
+    if (!uploadResponse.ok) {
+      throw new Error(
+        `Failed to upload asset files: ${uploadResponse.status} ${uploadResponse.statusText}`
+      );
+    }
+
+    const uploadData = (await uploadResponse.json()) as UploadResponse;
+    // Update the completion token for the next batch
+    if (uploadData.result.jwt) {
+      completionToken = uploadData.result.jwt;
+    }
+  }
+
+  // Return the final completion token
+  return {
+    completionToken,
+    assetConfig: {
+      html_handling: "auto-trailing-slash",
+    },
+  };
+}
+
+/**
+ * Calculate the SHA-256 hash and size of a file
+ *
+ * @param filePath Path to the file
+ * @returns Hash (first 32 chars of SHA-256) and size of the file
+ */
+async function calculateFileMetadata(
+  filePath: string
+): Promise<{ hash: string; size: number }> {
+  const hash = crypto.createHash("sha256");
+  const fileContent = await fs.readFile(filePath);
+
+  hash.update(fileContent);
+  const fileHash = hash.digest("hex").substring(0, 32); // First 32 chars of hash
+
+  return {
+    hash: fileHash,
+    size: fileContent.length,
+  };
+}

package/src/dns/import-dns.ts

@@ -134,7 +134,7 @@ export const ImportDnsRecords = Resource(
   async function (
     this: Context<ImportDnsRecords>,
     id: string,
-    props: ImportDnsRecordsProps,
+    props: ImportDnsRecordsProps
   ): Promise<ImportDnsRecords> {
     // For delete phase, just return destroyed state since this is a read-only resource
     if (this.phase === "delete") {
@@ -152,7 +152,7 @@ export const ImportDnsRecords = Resource(
             headers: {
               accept: "application/dns-json",
             },
-          },
+          }
         );
 
         if (!res.ok) {
@@ -197,7 +197,7 @@ export const ImportDnsRecords = Resource(
       } catch (error) {
         console.warn(
           `Failed to fetch ${type} records for ${props.domain}:`,
-          error,
+          error
         );
       }
     }
@@ -209,5 +209,5 @@ export const ImportDnsRecords = Resource(
       records: allRecords,
       importedAt: Date.now(),
     });
-  },
+  }
 );