alchemy 0.68.0 → 0.69.1

package/src/cloudflare/api.ts

@@ -1,5 +1,6 @@
 import { Provider, type Credentials } from "../auth.ts";
 import type { Secret } from "../secret.ts";
+import { isBinary } from "../serde.ts";
 import { memoize } from "../util/memoize.ts";
 import { withExponentialBackoff } from "../util/retry.ts";
 import { safeFetch } from "../util/safe-fetch.ts";
@@ -257,7 +258,7 @@ export class CloudflareApi {
     return this.fetch(path, {
       ...init,
       method: "POST",
-      body: this.toBody(body),
+      body: await this.toBody(body),
     });
   }
 
@@ -272,18 +273,16 @@ export class CloudflareApi {
     return this.fetch(path, {
       ...init,
       method: "PUT",
-      body: this.toBody(body),
+      body: await this.toBody(body),
     });
   }
 
-  toBody(body: BodyInit): BodyInit {
-    return body instanceof FormData
+  async toBody(body: BodyInit): Promise<BodyInit> {
+    return body instanceof FormData ||
+      typeof body === "string" ||
+      isBinary(body)
       ? body
-      : typeof body === "string"
-        ? body
-        : body instanceof ReadableStream
-          ? body
-          : JSON.stringify(body);
+      : JSON.stringify(body);
   }
 
   /**
@@ -297,7 +296,7 @@ export class CloudflareApi {
     return this.fetch(path, {
       ...init,
       method: "PATCH",
-      body: this.toBody(body),
+      body: await this.toBody(body),
     });
   }
 

package/src/cloudflare/astro/astro.ts

@@ -3,7 +3,12 @@ import { getPackageManagerRunner } from "../../util/detect-package-manager.ts";
 import type { Assets } from "../assets.ts";
 import type { Bindings } from "../bindings.ts";
 import { withSkipPathValidation } from "../miniflare/paths.ts";
-import { Website, type WebsiteProps } from "../website.ts";
+import {
+  spreadBuildProps,
+  spreadDevProps,
+  Website,
+  type WebsiteProps,
+} from "../website.ts";
 import type { Worker } from "../worker.ts";
 
 /**
@@ -75,8 +80,8 @@ export async function Astro<B extends Bindings>(
   return await Website(id, {
     ...props,
     noBundle: props.noBundle ?? true,
-    build: props.build ?? `${runner} astro build`,
-    dev: props.dev ?? `${runner} astro dev`,
+    build: spreadBuildProps(props, `${runner} astro build`),
+    dev: spreadDevProps(props, `${runner} astro dev`),
     entrypoint:
       props.entrypoint ??
       (output === "server" ? "dist/_worker.js/index.js" : undefined),

package/src/cloudflare/bucket-object.ts

@@ -0,0 +1,127 @@
+import type { R2PutOptions } from "@cloudflare/workers-types/experimental/index.ts";
+import type { Context } from "../context.ts";
+import { Resource } from "../resource.ts";
+import { createCloudflareApi, type CloudflareApiOptions } from "./api.ts";
+import { deleteObject, type PutObjectObject, type R2Bucket } from "./bucket.ts";
+
+/**
+ * Properties for creating or updating an R2 Object
+ */
+export interface R2ObjectProps extends CloudflareApiOptions {
+  /**
+   * The R2 bucket where the object will be stored
+   */
+  bucket: R2Bucket;
+
+  /**
+   * The key (path/name) of the object within the bucket
+   * Must be a valid object key as defined by R2 storage requirements
+   */
+  key: string;
+
+  /**
+   * The content to store in the object
+   * Supports various data types including streams, buffers, strings, and blobs
+   */
+  content: PutObjectObject;
+
+  /**
+   * The options to use for the object
+   */
+  options?: Pick<R2PutOptions, "httpMetadata">;
+}
+
+/**
+ * Output returned after R2 Object creation/update
+ */
+export interface R2Object {
+  /**
+   * The resource identifier
+   */
+  id: string;
+
+  /**
+   * The key (path/name) of the object within the bucket
+   */
+  key: string;
+
+  /**
+   * The etag of the object
+   */
+  etag: string;
+}
+
+/**
+ * Creates and manages objects within Cloudflare R2 Buckets.
+ *
+ * R2 Objects represent individual files or data stored within an R2 bucket.
+ * This resource provides lifecycle management for object creation, updates, and deletion.
+ *
+ * @example
+ * // Create a simple text object in a bucket
+ * const textObject = await R2Object("readme", {
+ *   bucket: myBucket,
+ *   key: "docs/README.txt",
+ *   content: "Welcome to our application!"
+ * });
+ *
+ * @example
+ * // Store JSON data as an object
+ * const configObject = await R2Object("app-config", {
+ *   bucket: configBucket,
+ *   key: "config/app.json",
+ *   content: JSON.stringify({ version: "1.0.0", debug: false })
+ * });
+ *
+ * @example
+ * // Store binary data from a buffer
+ * const imageObject = await R2Object("user-avatar", {
+ *   bucket: assetsBucket,
+ *   key: "avatars/user-123.png",
+ *   content: imageBuffer
+ * });
+ *
+ * @example
+ * // Store data from a readable stream
+ * const streamObject = await R2Object("upload", {
+ *   bucket: uploadsBucket,
+ *   key: "uploads/file.dat",
+ *   content: readableStream
+ * });
+ *
+ * @see https://developers.cloudflare.com/r2/api/workers/workers-api-reference/
+ */
+export const R2Object = Resource(
+  "cloudflare::R2Object",
+  async function (
+    this: Context<R2Object>,
+    id: string,
+    props: R2ObjectProps,
+  ): Promise<R2Object> {
+    if (this.phase === "delete") {
+      const api = await createCloudflareApi(props);
+      // Delete the object from the bucket
+      await deleteObject(api, {
+        bucketName: props.bucket.name,
+        key: props.key,
+      });
+      return this.destroy();
+    } else {
+      if (this.phase === "update" && this.output?.key !== props.key) {
+        this.replace();
+      }
+      // Create or update the object in the bucket
+      const response = await props.bucket.put(
+        props.key,
+        props.content,
+        props.options,
+      );
+
+      return {
+        id,
+        key: props.key,
+        etag: response.etag,
+      };
+    }
+  },
+);

package/src/cloudflare/bucket.ts

@@ -1,7 +1,10 @@
+import type { R2PutOptions } from "@cloudflare/workers-types/experimental/index.ts";
+import * as mf from "miniflare";
 import { isDeepStrictEqual } from "node:util";
 import type { Context } from "../context.ts";
 import { Resource, ResourceKind } from "../resource.ts";
 import { Scope } from "../scope.ts";
+import { streamToBuffer } from "../serde.ts";
 import { isRetryableError } from "../state/r2-rest-state-store.ts";
 import { withExponentialBackoff } from "../util/retry.ts";
 import { CloudflareApiError, handleApiError } from "./api-error.ts";
@@ -15,6 +18,7 @@ import {
   type CloudflareApiOptions,
 } from "./api.ts";
 import { deleteMiniflareBinding } from "./miniflare/delete.ts";
+import { getDefaultPersistPath } from "./miniflare/paths.ts";
 
 export type R2BucketJurisdiction = "default" | "eu" | "fedramp";
 
@@ -89,6 +93,11 @@ export interface BucketProps extends CloudflareApiOptions {
    */
   lock?: R2BucketLockRule[];
 
+  /**
+   * Enable data catalog for bucket
+   */
+  dataCatalog?: boolean;
+
   /**
    * Whether to emulate the bucket locally when Alchemy is running in watch mode.
    */
@@ -245,9 +254,10 @@ export type R2ObjectMetadata = {
   etag: string;
   uploaded: Date;
   size: number;
+  httpMetadata?: R2HTTPMetadata;
 };
 
-export type R2Object = R2ObjectMetadata & {
+export type R2ObjectContent = R2ObjectMetadata & {
   arrayBuffer(): Promise<ArrayBuffer>;
   bytes(): Promise<Uint8Array>;
   text(): Promise<string>;
@@ -264,7 +274,7 @@ export type PutR2ObjectResponse = {
 };
 
 export type R2Objects = {
-  objects: R2ObjectMetadata[];
+  objects: Omit<R2ObjectMetadata, "httpMetadata">[];
 } & (
   | {
       truncated: true;
@@ -278,7 +288,7 @@ export type R2Objects = {
 
 export type R2Bucket = _R2Bucket & {
   head(key: string): Promise<R2ObjectMetadata | null>;
-  get(key: string): Promise<R2Object | null>;
+  get(key: string): Promise<R2ObjectContent | null>;
   put(
     key: string,
     value:
@@ -288,6 +298,7 @@ export type R2Bucket = _R2Bucket & {
       | string
       | null
       | Blob,
+    options?: Pick<R2PutOptions, "httpMetadata">,
   ): Promise<PutR2ObjectResponse>;
   delete(key: string): Promise<Response>;
   list(options?: R2ListOptions): Promise<R2Objects>;
@@ -337,6 +348,24 @@ type _R2Bucket = Omit<BucketProps, "delete" | "dev"> & {
      */
     remote: boolean;
   };
+
+  /**
+   * Data catalog for the bucket
+   */
+  catalog?: {
+    /**
+     * ID of the data catalog
+     */
+    id: string;
+    /**
+     * Name of the data catalog
+     */
+    name: string;
+    /**
+     * Host of the data catalog
+     */
+    host: string;
+  };
 };
 
 export function isBucket(resource: any): resource is R2Bucket {
@@ -391,6 +420,8 @@ export async function R2Bucket(
   id: string,
   props: BucketProps = {},
 ): Promise<R2Bucket> {
+  const scope = Scope.current;
+  const isLocal = scope.local && props.dev?.remote !== true;
   const api = await createCloudflareApi(props);
   const bucket = await _R2Bucket(id, {
     ...props,
@@ -399,14 +430,54 @@ export async function R2Bucket(
       force: Scope.current.local,
     },
   });
+
+  let _miniflare: mf.Miniflare | undefined;
+  const miniflare = () => {
+    if (_miniflare) {
+      return _miniflare;
+    }
+    _miniflare = new mf.Miniflare({
+      script: "",
+      modules: true,
+      defaultPersistRoot: getDefaultPersistPath(scope.rootDir),
+      r2Buckets: [bucket.dev.id],
+      log: process.env.DEBUG ? new mf.Log(mf.LogLevel.DEBUG) : undefined,
+    });
+    scope.onCleanup(async () => _miniflare?.dispose());
+    return _miniflare;
+  };
+  const localBucket = () => miniflare().getR2Bucket(bucket.dev.id);
+
   return {
     ...bucket,
-    head: async (key: string) =>
-      headObject(api, {
+    head: async (key: string) => {
+      if (isLocal) {
+        const result = await (await localBucket()).head(key);
+        if (result) {
+          return {
+            key: result.key,
+            etag: result.etag,
+            uploaded: result.uploaded,
+            size: result.size,
+            httpMetadata: result.httpMetadata,
+          } as R2ObjectMetadata;
+        }
+        return null;
+      }
+      return headObject(api, {
         bucketName: bucket.name,
         key,
-      }),
+      });
+    },
     get: async (key: string) => {
+      if (isLocal) {
+        const result = await (await localBucket()).get(key);
+        if (result) {
+          // cast because workers vs node built-ins
+          return result as unknown as R2ObjectContent;
+        }
+        return null;
+      }
       const response = await getObject(api, {
         bucketName: bucket.name,
         key,
@@ -419,19 +490,42 @@ export async function R2Bucket(
         throw await handleApiError(response, "get", "object", key);
       }
     },
-    list: async (options?: R2ListOptions): Promise<R2Objects> =>
-      listObjects(api, bucket.name, {
+    list: async (options?: R2ListOptions): Promise<R2Objects> => {
+      if (isLocal) {
+        return (await localBucket()).list(options);
+      }
+      return listObjects(api, bucket.name, {
         ...options,
         jurisdiction: bucket.jurisdiction,
-      }),
+      });
+    },
     put: async (
       key: string,
       value: PutObjectObject,
+      options?: Pick<R2PutOptions, "httpMetadata">,
     ): Promise<PutR2ObjectResponse> => {
+      if (isLocal) {
+        return await (await localBucket()).put(
+          key,
+          typeof value === "string"
+            ? value
+            : Buffer.isBuffer(value) ||
+                value instanceof Uint8Array ||
+                value instanceof ArrayBuffer
+              ? new Uint8Array(value)
+              : value instanceof Blob
+                ? new Uint8Array(await value.arrayBuffer())
+                : value instanceof ReadableStream
+                  ? new Uint8Array(await streamToBuffer(value))
+                  : value,
+          options,
+        );
+      }
       const response = await putObject(api, {
         bucketName: bucket.name,
         key: key,
         object: value,
+        options: options,
       });
       const body = (await response.json()) as {
         result: {
@@ -450,19 +544,24 @@ export async function R2Bucket(
         size: Number(body.result.size),
       };
     },
-    delete: async (key: string) =>
-      deleteObject(api, {
+    delete: async (key: string) => {
+      if (isLocal) {
+        await (await localBucket()).delete(key);
+      }
+      return deleteObject(api, {
         bucketName: bucket.name,
         key: key,
-      }),
+      });
+    },
   };
 }
 
-const parseR2Object = (key: string, response: Response): R2Object => ({
+const parseR2Object = (key: string, response: Response): R2ObjectContent => ({
   etag: response.headers.get("ETag")!,
   uploaded: parseDate(response.headers),
   key,
   size: Number(response.headers.get("Content-Length")),
+  httpMetadata: mapHeadersToHttpMetadata(response.headers),
   arrayBuffer: () => response.arrayBuffer(),
   bytes: () => response.bytes(),
   text: () => response.text(),
@@ -481,7 +580,7 @@ const _R2Bucket = Resource(
     props: BucketProps = {},
   ): Promise<_R2Bucket> {
     const bucketName =
-      props.name ?? this.output?.name ?? this.scope.createPhysicalName(id);
+      props.name ?? (this.output?.name || this.scope.createPhysicalName(id));
 
     if (this.phase === "update" && this.output?.name !== bucketName) {
       this.replace();
@@ -513,6 +612,9 @@ const _R2Bucket = Resource(
 
     if (this.phase === "delete") {
       if (props.delete !== false) {
+        if (this.output?.catalog) {
+          await disableDataCatalog(api, bucketName);
+        }
         if (this.output.dev?.id) {
           await deleteMiniflareBinding(this.scope, "r2", this.output.dev.id);
         }
@@ -552,6 +654,16 @@ const _R2Bucket = Resource(
       if (props.lock?.length) {
         await putBucketLockRules(api, bucketName, props);
       }
+      let dataCatalog:
+        | {
+            id: string;
+            name: string;
+            host: string;
+          }
+        | undefined;
+      if (props.dataCatalog) {
+        dataCatalog = await enableDataCatalog(api, bucketName);
+      }
       return {
         name: bucketName,
         location: bucket.location,
@@ -565,6 +677,7 @@ const _R2Bucket = Resource(
         lock: props.lock,
         cors: props.cors,
         dev,
+        catalog: dataCatalog,
       };
     } else {
       if (bucketName !== this.output.name) {
@@ -572,6 +685,13 @@ const _R2Bucket = Resource(
           `Cannot update R2Bucket name after creation. Bucket name is immutable. Before: ${this.output.name}, After: ${bucketName}`,
         );
       }
+      if (this.output?.catalog && !props.dataCatalog) {
+        await disableDataCatalog(api, bucketName);
+        this.output.catalog = undefined;
+      }
+      if (!this.output.catalog && props.dataCatalog) {
+        this.output.catalog = await enableDataCatalog(api, bucketName);
+      }
       let domain = this.output.domain;
       if (!!domain !== allowPublicAccess) {
         domain = await putManagedDomain(
@@ -1051,6 +1171,7 @@ export async function headObject(
     etag: response.headers.get("ETag")?.replace(/"/g, "")!,
     uploaded: parseDate(response.headers),
     size: Number(response.headers.get("Content-Length")),
+    httpMetadata: mapHeadersToHttpMetadata(response.headers),
   };
 }
 
@@ -1079,34 +1200,85 @@ export async function getObject(
   });
 }
 
-type PutObjectObject =
+export type PutObjectObject =
   | ReadableStream
   | ArrayBuffer
   | ArrayBufferView
+  | Uint8Array
   | string
+  | Buffer
   | Blob;
 
+function mapHttpMetadataToHeaders(
+  httpMetadata: R2PutOptions["httpMetadata"],
+): Record<string, string> {
+  const headers: Record<string, string> = {};
+
+  if (httpMetadata instanceof Headers) {
+    httpMetadata.forEach((value, key) => {
+      headers[key] = value;
+    });
+  } else {
+    const {
+      contentType,
+      contentLanguage,
+      contentDisposition,
+      contentEncoding,
+      cacheControl,
+      cacheExpiry,
+    } = httpMetadata as R2HTTPMetadata;
+    if (contentType) headers["Content-Type"] = contentType;
+    if (contentLanguage) headers["Content-Language"] = contentLanguage;
+    if (contentDisposition) headers["Content-Disposition"] = contentDisposition;
+    if (contentEncoding) headers["Content-Encoding"] = contentEncoding;
+    if (cacheControl) headers["Cache-Control"] = cacheControl;
+    if (cacheExpiry) headers.Expires = cacheExpiry.toUTCString();
+  }
+
+  return headers;
+}
+
+function mapHeadersToHttpMetadata(headers: Headers): R2HTTPMetadata {
+  return {
+    contentType: headers.get("Content-Type") ?? undefined,
+    contentLanguage: headers.get("Content-Language") ?? undefined,
+    contentDisposition: headers.get("Content-Disposition") ?? undefined,
+    contentEncoding: headers.get("Content-Encoding") ?? undefined,
+    cacheControl: headers.get("Cache-Control") ?? undefined,
+    cacheExpiry: headers.get("Expires")
+      ? new Date(headers.get("Expires")!)
+      : undefined,
+  };
+}
+
 export async function putObject(
   api: CloudflareApi,
   {
     bucketName,
     key,
     object,
+    options,
   }: {
     bucketName: string;
     key: string;
     object: PutObjectObject;
+    options?: Pick<R2PutOptions, "httpMetadata">;
   },
 ): Promise<Response> {
   // Using withExponentialBackoff for reliability
   return await withRetries(async () => {
+    const headers: Record<string, string> = {
+      "Content-Type": "application/octet-stream",
+      ...(options?.httpMetadata
+        ? mapHttpMetadataToHeaders(options?.httpMetadata)
+        : {}),
+    };
+
     const response = await api.put(
       `/accounts/${api.accountId}/r2/buckets/${bucketName}/objects/${key}`,
       object,
       {
-        headers: {
-          "Content-Type": "application/octet-stream",
-        },
+        headers,
       },
     );
     if (!response.ok) {
@@ -1132,3 +1304,31 @@ export async function deleteObject(
     return response;
   });
 }
+
+export async function enableDataCatalog(
+  api: CloudflareApi,
+  bucketName: string,
+) {
+  const response = await extractCloudflareResult<{
+    id: string;
+    name: string;
+  }>(
+    `enable data catalog for bucket "${bucketName}"`,
+    api.post(`/accounts/${api.accountId}/r2-catalog/${bucketName}/enable`, {}),
+  );
+  return {
+    id: response.id,
+    name: response.name,
+    host: `https://catalog.cloudflarestorage.com/${response.name.replace("_", "/")}`,
+  };
+}
+
+export async function disableDataCatalog(
+  api: CloudflareApi,
+  bucketName: string,
+) {
+  await api.post(
+    `/accounts/${api.accountId}/r2-catalog/${bucketName}/disable`,
+    {},
+  );
+}

package/src/cloudflare/compatibility-date.gen.ts

@@ -4,4 +4,4 @@
 /**
  * The default Cloudflare Workers compatibility date, set based on the latest workerd release at the time of build.
  */
-export const DEFAULT_COMPATIBILITY_DATE = "2025-09-24";
+export const DEFAULT_COMPATIBILITY_DATE = "2025-09-27";

package/src/cloudflare/container.ts

@@ -950,14 +950,13 @@ export async function updateContainerApplication(
   );
   const result = (await response.json()) as {
     result: ContainerApplicationData;
-    errors: { message: string }[];
+    errors: { message: string; code: number }[];
   };
   if (response.ok) {
     return result.result;
   }
-
   throw Error(
-    `Failed to create container application: ${result.errors?.map((e: { message: string }) => e.message).join(", ") ?? "Unknown error"}`,
+    `Failed to create container application: ${result.errors?.map((e) => `[${e.code}] ${e.message}`).join(", ") ?? "Unknown error"}`,
   );
 }
 
@@ -1045,13 +1044,13 @@ export async function createContainerApplicationRollout(
   );
   const result = (await response.json()) as {
     result: CreateRolloutApplicationResponse;
-    errors: { message: string }[];
+    errors: { message: string; code: number }[];
   };
   if (response.ok) {
     return result.result;
   }
   throw Error(
-    `Failed to create container application rollout: ${result.errors.map((e: { message: string }) => e.message).join(", ")}`,
+    `Failed to create container application rollout: ${result.errors.map((e) => `[${e.code}] ${e.message}`).join(", ")}`,
   );
 }
 

package/src/cloudflare/index.ts

@@ -13,6 +13,7 @@ export * from "./astro/astro.ts";
 export * from "./bindings.ts";
 export * from "./bound.ts";
 export * from "./browser-rendering.ts";
+export * from "./bucket-object.ts";
 export * from "./bucket.ts";
 export * from "./certificate-pack.ts";
 export * from "./cloudflare-env-proxy.ts";