alchemy 0.1.16 → 0.1.17

package/lib/utils/content-type.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"content-type.js","sourceRoot":"","sources":["../../src/utils/content-type.ts"],"names":[],"mappings":"AAAA,OAAO,IAAI,MAAM,MAAM,CAAC;AAExB,oBAAoB;AACpB,MAAM,SAAS,GAA2B;IACxC,OAAO,EAAE,WAAW;IACpB,MAAM,EAAE,WAAW;IACnB,MAAM,EAAE,UAAU;IAClB,KAAK,EAAE,wBAAwB;IAC/B,OAAO,EAAE,kBAAkB;IAC3B,MAAM,EAAE,iBAAiB;IACzB,MAAM,EAAE,YAAY;IACpB,KAAK,EAAE,eAAe;IACtB,MAAM,EAAE,WAAW;IACnB,MAAM,EAAE,YAAY;IACpB,OAAO,EAAE,YAAY;IACrB,MAAM,EAAE,WAAW;IACnB,OAAO,EAAE,YAAY;IACrB,MAAM,EAAE,eAAe;IACvB,MAAM,EAAE,cAAc;IACtB,MAAM,EAAE,iBAAiB;IACzB,MAAM,EAAE,iBAAiB;IACzB,OAAO,EAAE,WAAW;IACpB,QAAQ,EAAE,YAAY;IACtB,MAAM,EAAE,UAAU;IAClB,MAAM,EAAE,UAAU;IAClB,MAAM,EAAE,+BAA+B;IACvC,MAAM,EAAE,WAAW;IACnB,OAAO,EAAE,YAAY;IACrB,MAAM,EAAE,YAAY;IACpB,MAAM,EAAE,WAAW;CACpB,CAAC;AAEF;;;;;GAKG;AACH,MAAM,UAAU,cAAc,CAAC,QAAgB;IAC7C,MAAM,SAAS,GAAG,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC,WAAW,EAAE,CAAC;IACvD,OAAO,SAAS,CAAC,SAAS,CAAC,IAAI,0BAA0B,CAAC;AAC5D,CAAC"}

package/lib/utils/retry.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Utility function for exponential backoff retry
+ * Retries an operation with exponential backoff when a retryable error occurs
+ *
+ * @param operation The async operation to execute and potentially retry
+ * @param isRetryable Function to determine if an error should trigger a retry
+ * @param maxAttempts Maximum number of attempts before giving up
+ * @param initialDelayMs Initial delay in milliseconds before first retry
+ * @returns Result of the operation
+ * @throws The last error encountered if all retries fail
+ */
+export declare function withExponentialBackoff<T>(operation: () => Promise<T>, isRetryable: (error: any) => boolean, maxAttempts?: number, initialDelayMs?: number): Promise<T>;
+//# sourceMappingURL=retry.d.ts.map

package/lib/utils/retry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"retry.d.ts","sourceRoot":"","sources":["../../src/utils/retry.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,wBAAsB,sBAAsB,CAAC,CAAC,EAC5C,SAAS,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,EAC3B,WAAW,EAAE,CAAC,KAAK,EAAE,GAAG,KAAK,OAAO,EACpC,WAAW,SAAI,EACf,cAAc,SAAM,GACnB,OAAO,CAAC,CAAC,CAAC,CAoBZ"}

package/lib/utils/retry.js

@@ -0,0 +1,32 @@
+/**
+ * Utility function for exponential backoff retry
+ * Retries an operation with exponential backoff when a retryable error occurs
+ *
+ * @param operation The async operation to execute and potentially retry
+ * @param isRetryable Function to determine if an error should trigger a retry
+ * @param maxAttempts Maximum number of attempts before giving up
+ * @param initialDelayMs Initial delay in milliseconds before first retry
+ * @returns Result of the operation
+ * @throws The last error encountered if all retries fail
+ */
+export async function withExponentialBackoff(operation, isRetryable, maxAttempts = 5, initialDelayMs = 100) {
+    let attempt = 0;
+    let delay = initialDelayMs;
+    while (true) {
+        try {
+            return await operation();
+        }
+        catch (error) {
+            attempt++;
+            if (attempt >= maxAttempts || !isRetryable(error)) {
+                console.warn("Failed after ", attempt, " attempts");
+                throw error;
+            }
+            // Exponential backoff with jitter
+            const jitter = Math.random() * 0.1 * delay;
+            await new Promise((resolve) => setTimeout(resolve, delay + jitter));
+            delay *= 2; // Double the delay for next attempt
+        }
+    }
+}
+//# sourceMappingURL=retry.js.map

package/lib/utils/retry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"retry.js","sourceRoot":"","sources":["../../src/utils/retry.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,MAAM,CAAC,KAAK,UAAU,sBAAsB,CAC1C,SAA2B,EAC3B,WAAoC,EACpC,WAAW,GAAG,CAAC,EACf,cAAc,GAAG,GAAG;IAEpB,IAAI,OAAO,GAAG,CAAC,CAAC;IAChB,IAAI,KAAK,GAAG,cAAc,CAAC;IAE3B,OAAO,IAAI,EAAE,CAAC;QACZ,IAAI,CAAC;YACH,OAAO,MAAM,SAAS,EAAE,CAAC;QAC3B,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,OAAO,EAAE,CAAC;YACV,IAAI,OAAO,IAAI,WAAW,IAAI,CAAC,WAAW,CAAC,KAAK,CAAC,EAAE,CAAC;gBAClD,OAAO,CAAC,IAAI,CAAC,eAAe,EAAE,OAAO,EAAE,WAAW,CAAC,CAAC;gBACpD,MAAM,KAAK,CAAC;YACd,CAAC;YAED,kCAAkC;YAClC,MAAM,MAAM,GAAG,IAAI,CAAC,MAAM,EAAE,GAAG,GAAG,GAAG,KAAK,CAAC;YAC3C,MAAM,IAAI,OAAO,CAAC,CAAC,OAAO,EAAE,EAAE,CAAC,UAAU,CAAC,OAAO,EAAE,KAAK,GAAG,MAAM,CAAC,CAAC,CAAC;YACpE,KAAK,IAAI,CAAC,CAAC,CAAC,oCAAoC;QAClD,CAAC;IACH,CAAC;AACH,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "alchemy",
-  "version": "0.1.16",
+  "version": "0.1.17",
   "type": "module",
   "module": "./lib/index.js",
   "scripts": {

package/src/cloudflare/bindings.ts

@@ -3,6 +3,7 @@
  * Based on Cloudflare API documentation:
  * https://developers.cloudflare.com/api/resources/workers/subresources/scripts/methods/update/
  */
+import type { Bucket } from "./bucket";
 import type { DurableObjectNamespace } from "./durable-object-namespace";
 import type { KVNamespace } from "./kv-namespace";
 import type { Worker } from "./worker";
@@ -14,7 +15,12 @@ export type Bindings = {
 /**
  * L2 Binding Resources.
  */
-export type Binding = DurableObjectNamespace | KVNamespace | Worker | string;
+export type Binding =
+  | DurableObjectNamespace
+  | KVNamespace
+  | Worker
+  | Bucket
+  | string;
 
 /**
  * Union type for all Worker binding types (API spec)

package/src/cloudflare/bucket.ts

@@ -0,0 +1,240 @@
+import type { Resolved } from "../output";
+import { type Context, Resource } from "../resource";
+import { createCloudflareApi } from "./api";
+
+/**
+ * Properties for creating or updating an R2 Bucket
+ */
+export interface BucketProps {
+  /**
+   * Name of the bucket
+   * Names can only contain lowercase letters (a-z), numbers (0-9), and hyphens (-)
+   * Cannot begin or end with a hyphen
+   */
+  name?: string;
+
+  /**
+   * Optional location hint for the bucket
+   * Indicates the primary geographical location data will be accessed from
+   */
+  locationHint?: string;
+
+  /**
+   * Optional jurisdiction for the bucket
+   * Determines the regulatory jurisdiction the bucket data falls under
+   */
+  jurisdiction?: "default" | "eu" | "fedramp";
+
+  /**
+   * Whether to allow public access through the r2.dev subdomain
+   * Only for development purposes - use custom domains for production
+   */
+  allowPublicAccess?: boolean;
+}
+
+/**
+ * Output returned after R2 Bucket creation/update
+ */
+export interface BucketOutput extends BucketProps {
+  /**
+   * The ID of the bucket (same as name)
+   */
+  id: string;
+
+  /**
+   * Location of the bucket
+   */
+  location: string;
+
+  /**
+   * Time at which the bucket was created (Unix timestamp in seconds)
+   */
+  creationDate: number;
+
+  /**
+   * Resource type identifier
+   */
+  type: "r2_bucket";
+}
+
+/**
+ * Cloudflare R2 bucket API response
+ */
+interface CloudflareBucketResponse {
+  result: {
+    name: string;
+    location?: string;
+    creation_date: string;
+  };
+  success: boolean;
+  errors: Array<{ code: number; message: string }>;
+  messages: string[];
+}
+
+export function isBucket(resource: any): resource is Resolved<Bucket> {
+  return (
+    resource && typeof resource === "object" && resource.id && resource.location
+  );
+}
+
+export class Bucket extends Resource(
+  "cloudflare::Bucket",
+  async (ctx: Context<BucketOutput>, props: BucketProps) => {
+    // Create Cloudflare API client with automatic account discovery
+    const api = await createCloudflareApi();
+
+    // Resource ID defaults to bucket name if provided
+    const bucketName = props.name || ctx.resourceID;
+
+    if (ctx.event === "delete") {
+      if (ctx.output?.id) {
+        // Delete R2 bucket
+        const headers: Record<string, string> = {};
+        if (props.jurisdiction && props.jurisdiction !== "default") {
+          headers["cf-r2-jurisdiction"] = props.jurisdiction;
+        }
+
+        const deleteResponse = await api.delete(
+          `/accounts/${api.accountId}/r2/buckets/${ctx.output.id}`,
+          { headers },
+        );
+
+        if (!deleteResponse.ok && deleteResponse.status !== 404) {
+          const errorData: any = await deleteResponse.json().catch(() => ({
+            errors: [{ message: deleteResponse.statusText }],
+          }));
+          throw new Error(
+            `Error deleting R2 bucket '${bucketName}': ${errorData.errors?.[0]?.message || deleteResponse.statusText}`,
+          );
+        }
+      }
+
+      // Return void (a deleted bucket has no content)
+      return;
+    } else {
+      try {
+        let bucketOutput: BucketOutput;
+
+        if (ctx.event === "update" && ctx.output?.id) {
+          // Get bucket details to verify it exists
+          const headers: Record<string, string> = {};
+          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: any = 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()) as CloudflareBucketResponse;
+          bucketOutput = {
+            id: result.result.name,
+            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: any = {
+            name: bucketName,
+          };
+
+          if (props.locationHint) {
+            createPayload.location_hint = props.locationHint;
+          }
+
+          const headers: Record<string, string> = {};
+          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: any = 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()) as CloudflareBucketResponse;
+          bucketOutput = {
+            id: result.result.name,
+            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);
+          }
+        }
+
+        return bucketOutput;
+      } catch (error) {
+        console.error("Error creating/updating R2 bucket:", error);
+        throw error;
+      }
+    }
+  },
+) {}
+
+/**
+ * Helper function to update the public access setting for a bucket
+ */
+async function updatePublicAccess(
+  api: any,
+  bucketName: string,
+  allowPublicAccess: boolean,
+): Promise<void> {
+  try {
+    const response = await api.put(
+      `/accounts/${api.accountId}/r2/buckets/${bucketName}/domains/managed`,
+      {
+        enabled: allowPublicAccess,
+      },
+    );
+
+    if (!response.ok) {
+      const errorData: any = await response.json().catch(() => ({
+        errors: [{ message: response.statusText }],
+      }));
+      throw new Error(
+        `Error updating R2 bucket public access: ${errorData.errors?.[0]?.message || response.statusText}`,
+      );
+    }
+  } catch (error) {
+    console.warn("Could not set public access:", error);
+  }
+}

package/src/cloudflare/index.ts

@@ -1,4 +1,5 @@
 export * from "./bindings";
+export * from "./bucket";
 export * from "./durable-object-namespace";
 export * from "./kv-namespace";
 export * from "./state";

package/src/cloudflare/static-site.ts

@@ -323,6 +323,18 @@ export class StaticSite extends Resource(
         },
       },
     };
+
+    // Determine the entrypoint file - check for .ts first, fallback to .js
+    let entrypointFile = "static-site-router.js";
+    try {
+      const tsFile = path.resolve(__dirname, "static-site-router.ts");
+      await fs.access(tsFile);
+      // If we reach here, the TypeScript file exists
+      entrypointFile = "static-site-router.ts";
+    } catch (error) {
+      // TypeScript file doesn't exist, use JavaScript (default)
+    }
+
     const worker = new Worker(
       "worker",
       {
@@ -333,7 +345,7 @@ export class StaticSite extends Resource(
         ...(props.workerScript
           ? { script: props.workerScript }
           : {
-              entrypoint: path.resolve(__dirname, "static-site-router.ts"),
+              entrypoint: path.resolve(__dirname, entrypointFile),
               bundle: bundleOptions,
             }),
         bindings,

package/src/cloudflare/worker.ts

@@ -6,6 +6,7 @@ import { type Context, Resource } from "../resource";
 import { withExponentialBackoff } from "../utils/retry";
 import { type CloudflareApi, createCloudflareApi } from "./api";
 import type { Bindings, WorkerBindingSpec } from "./bindings";
+import { isBucket } from "./bucket";
 import type { DurableObjectNamespace } from "./durable-object-namespace";
 import { isDurableObjectNamespace } from "./durable-object-namespace";
 import { isKVNamespace } from "./kv-namespace";
@@ -438,6 +439,12 @@ async function prepareWorkerMetadata(
           to: className,
         });
       }
+    } else if (isBucket(binding)) {
+      meta.bindings.push({
+        type: "r2_bucket",
+        name: bindingName,
+        bucket_name: binding.name || binding.id,
+      });
     } else {
       // @ts-expect-error - we should never reach here
       throw new Error(`Unsupported binding type: ${binding.type}`);