alchemy 0.66.0 → 0.68.0

package/src/cloudflare/bound.ts

@@ -1,6 +1,5 @@
 import type {
   Ai,
-  AiGateway,
   AnalyticsEngineDataset,
   D1Database,
   DispatchNamespace,
@@ -21,7 +20,6 @@ import type {
 } from "@cloudflare/workers-types";
 import type { Pipeline } from "cloudflare:pipelines";
 import type { Secret } from "../secret.ts";
-import type { AiGateway as _AiGateway } from "./ai-gateway.ts";
 import type { Ai as _Ai } from "./ai.ts";
 import type { AnalyticsEngineDataset as _AnalyticsEngineDataset } from "./analytics-engine.ts";
 import type { Assets } from "./assets.ts";
@@ -31,12 +29,14 @@ import type { R2Bucket as _R2Bucket } from "./bucket.ts";
 import type { Container as _Container } from "./container.ts";
 import type { D1Database as _D1Database } from "./d1-database.ts";
 import type { DurableObjectNamespace as _DurableObjectNamespace } from "./durable-object-namespace.ts";
+import type { HyperdriveRef } from "./hyperdrive-ref.ts";
 import type { Hyperdrive as _Hyperdrive } from "./hyperdrive.ts";
 import type { Images as _Images } from "./images.ts";
 import type { Pipeline as _Pipeline } from "./pipeline.ts";
 import type { Queue as _Queue } from "./queue.ts";
 import type { RateLimit as _RateLimit } from "./rate-limit.ts";
 import type { SecretKey } from "./secret-key.ts";
+import type { SecretRef as CloudflareSecretRef } from "./secret-ref.ts";
 import type { Secret as CloudflareSecret } from "./secret.ts";
 import type { VectorizeIndex as _VectorizeIndex } from "./vectorize-index.ts";
 import type { VersionMetadata as _VersionMetadata } from "./version-metadata.ts";
@@ -70,53 +70,51 @@ export type Bound<T extends Binding> = T extends _DurableObjectNamespace<
           ? Service
           : T extends _R2Bucket
             ? R2Bucket
-            : T extends _AiGateway
-              ? AiGateway
-              : T extends _Hyperdrive
-                ? Hyperdrive
-                : T extends Secret
-                  ? string
-                  : T extends CloudflareSecret
-                    ? SecretsStoreSecret
-                    : T extends SecretKey
-                      ? CryptoKey
-                      : T extends Assets
-                        ? Service
-                        : T extends _Workflow<infer P>
-                          ? Workflow<P>
-                          : T extends _D1Database
-                            ? D1Database
-                            : T extends DispatchNamespace
-                              ? DispatchNamespace
-                              : T extends _VectorizeIndex
-                                ? VectorizeIndex
-                                : T extends _Queue<infer Body>
-                                  ? Queue<Body>
-                                  : T extends _AnalyticsEngineDataset
-                                    ? AnalyticsEngineDataset
-                                    : T extends _Pipeline<infer R>
-                                      ? Pipeline<R>
-                                      : T extends _RateLimit
-                                        ? RateLimit
-                                        : T extends string
-                                          ? string
-                                          : T extends BrowserRendering
-                                            ? Fetcher
-                                            : T extends _Ai<infer M>
-                                              ? Ai<M>
-                                              : T extends _Images
-                                                ? ImagesBinding
-                                                : T extends _VersionMetadata
-                                                  ? WorkerVersionMetadata
-                                                  : T extends Self
-                                                    ? Service
-                                                    : T extends Json<infer T>
-                                                      ? T
-                                                      : T extends _Container<
-                                                            infer Obj
-                                                          >
-                                                        ? DurableObjectNamespace<
-                                                            Obj &
-                                                              Rpc.DurableObjectBranded
-                                                          >
-                                                        : Service;
+            : T extends _Hyperdrive | HyperdriveRef
+              ? Hyperdrive
+              : T extends Secret
+                ? string
+                : T extends CloudflareSecret | CloudflareSecretRef
+                  ? SecretsStoreSecret
+                  : T extends SecretKey
+                    ? CryptoKey
+                    : T extends Assets
+                      ? Service
+                      : T extends _Workflow<infer P>
+                        ? Workflow<P>
+                        : T extends _D1Database
+                          ? D1Database
+                          : T extends DispatchNamespace
+                            ? DispatchNamespace
+                            : T extends _VectorizeIndex
+                              ? VectorizeIndex
+                              : T extends _Queue<infer Body>
+                                ? Queue<Body>
+                                : T extends _AnalyticsEngineDataset
+                                  ? AnalyticsEngineDataset
+                                  : T extends _Pipeline<infer R>
+                                    ? Pipeline<R>
+                                    : T extends _RateLimit
+                                      ? RateLimit
+                                      : T extends string
+                                        ? T
+                                        : T extends BrowserRendering
+                                          ? Fetcher
+                                          : T extends _Ai<infer M>
+                                            ? Ai<M>
+                                            : T extends _Images
+                                              ? ImagesBinding
+                                              : T extends _VersionMetadata
+                                                ? WorkerVersionMetadata
+                                                : T extends Self
+                                                  ? Service
+                                                  : T extends Json<infer T>
+                                                    ? T
+                                                    : T extends _Container<
+                                                          infer Obj
+                                                        >
+                                                      ? DurableObjectNamespace<
+                                                          Obj &
+                                                            Rpc.DurableObjectBranded
+                                                        >
+                                                      : Service;

package/src/cloudflare/bucket.ts

@@ -2,8 +2,9 @@ import { isDeepStrictEqual } from "node:util";
 import type { Context } from "../context.ts";
 import { Resource, ResourceKind } from "../resource.ts";
 import { Scope } from "../scope.ts";
+import { isRetryableError } from "../state/r2-rest-state-store.ts";
 import { withExponentialBackoff } from "../util/retry.ts";
-import { CloudflareApiError } from "./api-error.ts";
+import { CloudflareApiError, handleApiError } from "./api-error.ts";
 import {
   extractCloudflareResult,
   type CloudflareApiErrorPayload,
@@ -239,55 +240,107 @@ interface R2BucketCORSRule {
   maxAgeSeconds?: number;
 }
 
+export type R2ObjectMetadata = {
+  key: string;
+  etag: string;
+  uploaded: Date;
+  size: number;
+};
+
+export type R2Object = R2ObjectMetadata & {
+  arrayBuffer(): Promise<ArrayBuffer>;
+  bytes(): Promise<Uint8Array>;
+  text(): Promise<string>;
+  json<T>(): Promise<T>;
+  blob(): Promise<Blob>;
+};
+
+export type PutR2ObjectResponse = {
+  key: string;
+  etag: string;
+  uploaded: Date;
+  version: string;
+  size: number;
+};
+
+export type R2Objects = {
+  objects: R2ObjectMetadata[];
+} & (
+  | {
+      truncated: true;
+      cursor: string;
+    }
+  | {
+      truncated: false;
+      cursor?: never;
+    }
+);
+
+export type R2Bucket = _R2Bucket & {
+  head(key: string): Promise<R2ObjectMetadata | null>;
+  get(key: string): Promise<R2Object | null>;
+  put(
+    key: string,
+    value:
+      | ReadableStream
+      | ArrayBuffer
+      | ArrayBufferView
+      | string
+      | null
+      | Blob,
+  ): Promise<PutR2ObjectResponse>;
+  delete(key: string): Promise<Response>;
+  list(options?: R2ListOptions): Promise<R2Objects>;
+};
+
 /**
  * Output returned after R2 Bucket creation/update
  */
-export type R2Bucket = Resource<"cloudflare::R2Bucket"> &
-  Omit<BucketProps, "delete" | "dev"> & {
-    /**
-     * Resource type identifier
-     */
-    type: "r2_bucket";
+type _R2Bucket = Omit<BucketProps, "delete" | "dev"> & {
+  /**
+   * Resource type identifier
+   */
+  type: "r2_bucket";
 
-    /**
-     * The name of the bucket
-     */
-    name: string;
+  /**
+   * The name of the bucket
+   */
+  name: string;
 
-    /**
-     * Location of the bucket
-     */
-    location: string;
+  /**
+   * Location of the bucket
+   */
+  location: string;
 
-    /**
-     * Time at which the bucket was created
-     */
-    creationDate: Date;
+  /**
+   * Time at which the bucket was created
+   */
+  creationDate: Date;
 
+  /**
+   * The `r2.dev` subdomain for the bucket, if `allowPublicAccess` is true
+   */
+  domain: string | undefined;
+
+  /**
+   * Development mode properties
+   * @internal
+   */
+  dev: {
     /**
-     * The `r2.dev` subdomain for the bucket, if `allowPublicAccess` is true
+     * The ID of the bucket in development mode
      */
-    domain: string | undefined;
+    id: string;
 
     /**
-     * Development mode properties
-     * @internal
+     * Whether the bucket is running remotely
      */
-    dev: {
-      /**
-       * The ID of the bucket in development mode
-       */
-      id: string;
-
-      /**
-       * Whether the bucket is running remotely
-       */
-      remote: boolean;
-    };
+    remote: boolean;
   };
+};
 
-export function isBucket(resource: Resource): resource is R2Bucket {
-  return resource[ResourceKind] === "cloudflare::R2Bucket";
+export function isBucket(resource: any): resource is R2Bucket {
+  return resource?.[ResourceKind] === "cloudflare::R2Bucket";
 }
 
 /**
@@ -338,22 +391,95 @@ export async function R2Bucket(
   id: string,
   props: BucketProps = {},
 ): Promise<R2Bucket> {
-  return await _R2Bucket(id, {
+  const api = await createCloudflareApi(props);
+  const bucket = await _R2Bucket(id, {
     ...props,
     dev: {
       ...(props.dev ?? {}),
       force: Scope.current.local,
     },
   });
+  return {
+    ...bucket,
+    head: async (key: string) =>
+      headObject(api, {
+        bucketName: bucket.name,
+        key,
+      }),
+    get: async (key: string) => {
+      const response = await getObject(api, {
+        bucketName: bucket.name,
+        key,
+      });
+      if (response.ok) {
+        return parseR2Object(key, response);
+      } else if (response.status === 404) {
+        return null;
+      } else {
+        throw await handleApiError(response, "get", "object", key);
+      }
+    },
+    list: async (options?: R2ListOptions): Promise<R2Objects> =>
+      listObjects(api, bucket.name, {
+        ...options,
+        jurisdiction: bucket.jurisdiction,
+      }),
+    put: async (
+      key: string,
+      value: PutObjectObject,
+    ): Promise<PutR2ObjectResponse> => {
+      const response = await putObject(api, {
+        bucketName: bucket.name,
+        key: key,
+        object: value,
+      });
+      const body = (await response.json()) as {
+        result: {
+          key: string;
+          etag: string;
+          uploaded: string;
+          version: string;
+          size: string;
+        };
+      };
+      return {
+        key: body.result.key,
+        etag: body.result.etag,
+        uploaded: new Date(body.result.uploaded),
+        version: body.result.version,
+        size: Number(body.result.size),
+      };
+    },
+    delete: async (key: string) =>
+      deleteObject(api, {
+        bucketName: bucket.name,
+        key: key,
+      }),
+  };
 }
 
+const parseR2Object = (key: string, response: Response): R2Object => ({
+  etag: response.headers.get("ETag")!,
+  uploaded: parseDate(response.headers),
+  key,
+  size: Number(response.headers.get("Content-Length")),
+  arrayBuffer: () => response.arrayBuffer(),
+  bytes: () => response.bytes(),
+  text: () => response.text(),
+  json: () => response.json(),
+  blob: () => response.blob(),
+});
+
+const parseDate = (headers: Headers) =>
+  new Date(headers.get("Last-Modified") ?? headers.get("Date")!);
+
 const _R2Bucket = Resource(
   "cloudflare::R2Bucket",
   async function (
-    this: Context<R2Bucket>,
+    this: Context<_R2Bucket>,
     id: string,
     props: BucketProps = {},
-  ): Promise<R2Bucket> {
+  ): Promise<_R2Bucket> {
     const bucketName =
       props.name ?? this.output?.name ?? this.scope.createPhysicalName(id);
 
@@ -369,7 +495,7 @@ const _R2Bucket = Resource(
     const adopt = props.adopt ?? this.scope.adopt;
 
     if (this.scope.local && !props.dev?.remote) {
-      return this({
+      return {
         name: this.output?.name ?? "",
         location: this.output?.location ?? "",
         creationDate: this.output?.creationDate ?? new Date(),
@@ -380,7 +506,7 @@ const _R2Bucket = Resource(
         accountId: this.output?.accountId ?? "",
         cors: props.cors,
         dev,
-      });
+      };
     }
 
     const api = await createCloudflareApi(props);
@@ -426,7 +552,7 @@ const _R2Bucket = Resource(
       if (props.lock?.length) {
         await putBucketLockRules(api, bucketName, props);
       }
-      return this({
+      return {
         name: bucketName,
         location: bucket.location,
         creationDate: new Date(bucket.creation_date),
@@ -439,7 +565,7 @@ const _R2Bucket = Resource(
         lock: props.lock,
         cors: props.cors,
         dev,
-      });
+      };
     } else {
       if (bucketName !== this.output.name) {
         throw new Error(
@@ -466,7 +592,7 @@ const _R2Bucket = Resource(
       if (!isDeepStrictEqual(this.output.lock ?? [], props.lock ?? [])) {
         await putBucketLockRules(api, bucketName, props);
       }
-      return this({
+      return {
         ...this.output,
         allowPublicAccess,
         dev,
@@ -474,7 +600,7 @@ const _R2Bucket = Resource(
         lifecycle: props.lifecycle,
         lock: props.lock,
         domain,
-      });
+      };
     }
   },
 );
@@ -613,17 +739,20 @@ async function emptyBucket(
 ) {
   let cursor: string | undefined;
   while (true) {
-    const result = await listObjects(api, bucketName, props, cursor);
-    if (result.keys.length) {
+    const result = await listObjects(api, bucketName, {
+      jurisdiction: props.jurisdiction,
+      cursor,
+    });
+    if (result.objects.length) {
       // Another undocumented API! But it lets us delete multiple objects at once instead of one by one.
       await extractCloudflareResult(
-        `delete ${result.keys.length} objects from bucket "${bucketName}"`,
+        `delete ${result.objects.length} objects from bucket "${bucketName}"`,
         api.delete(
           `/accounts/${api.accountId}/r2/buckets/${bucketName}/objects`,
           {
             headers: withJurisdiction(props),
             method: "DELETE",
-            body: JSON.stringify(result.keys),
+            body: JSON.stringify(result.objects.map((object) => object.key)),
           },
         ),
       );
@@ -642,21 +771,39 @@ async function emptyBucket(
 export async function listObjects(
   api: CloudflareApi,
   bucketName: string,
-  props: { jurisdiction?: string },
-  cursor?: string,
-) {
+  props: R2ListOptions & {
+    jurisdiction?: string;
+  },
+): Promise<R2Objects> {
   const params = new URLSearchParams({
     per_page: "1000",
   });
-  if (cursor) {
-    params.set("cursor", cursor);
+  if (props.cursor) {
+    params.set("cursor", props.cursor);
+  }
+  if (props.delimiter) {
+    params.set("delimiter", props.delimiter);
+  }
+  if (props.prefix) {
+    params.set("prefix", props.prefix);
+  }
+  if (props.startAfter) {
+    params.set("start_after", props.startAfter);
+  }
+  if (props.limit) {
+    params.set("limit", props.limit.toString());
   }
   const response = await api.get(
     `/accounts/${api.accountId}/r2/buckets/${bucketName}/objects?${params.toString()}`,
     { headers: withJurisdiction(props) },
   );
   const json: {
-    result: { key: string }[];
+    result: {
+      key: string;
+      etag: string;
+      last_modified: string;
+      size: number;
+    }[];
     result_info?: {
       cursor: string;
       is_truncated: boolean;
@@ -668,7 +815,11 @@ export async function listObjects(
   if (!json.success) {
     // 10006 indicates that the bucket does not exist, so there are no objects to list
     if (json.errors.some((e) => e.code === 10006)) {
-      return { keys: [], cursor: undefined };
+      return {
+        objects: [],
+        cursor: undefined,
+        truncated: false,
+      };
     }
     throw new CloudflareApiError(
       `Failed to list objects in bucket "${bucketName}": ${json.errors.map((e) => `- [${e.code}] ${e.message}${e.documentation_url ? ` (${e.documentation_url})` : ""}`).join("\n")}`,
@@ -677,9 +828,17 @@ export async function listObjects(
     );
   }
   return {
-    keys: json.result.map((object) => object.key),
+    // keys: json.result.map((object) => object.key),
+    objects: json.result.map((object) => ({
+      key: object.key,
+      etag: object.etag,
+      uploaded: new Date(object.last_modified),
+      size: object.size,
+    })),
+    delimitedPrefixes: [],
     cursor: json.result_info?.cursor,
-  };
+    truncated: json.result_info?.is_truncated ?? false,
+  } as R2Objects;
 }
 
 /**
@@ -869,3 +1028,107 @@ export async function getBucketLockRules(
     : (json.result?.rules ?? []);
   return rules as R2BucketLockRule[];
 }
+
+export async function headObject(
+  api: CloudflareApi,
+  { bucketName, key }: { bucketName: string; key: string },
+): Promise<R2ObjectMetadata | null> {
+  const response = await withRetries(
+    async () =>
+      await api.get(
+        `/accounts/${api.accountId}/r2/buckets/${bucketName}/objects/${key}`,
+      ),
+  );
+  // for some reason HEAD returns 404 for keys that exist, this is the best we can do without using S3 API
+  response.body?.cancel();
+  if (response.status === 404) {
+    return null;
+  } else if (!response.ok) {
+    throw await handleApiError(response, "head", "object", key);
+  }
+  return {
+    key,
+    etag: response.headers.get("ETag")?.replace(/"/g, "")!,
+    uploaded: parseDate(response.headers),
+    size: Number(response.headers.get("Content-Length")),
+  };
+}
+
+const withRetries = (f: () => Promise<Response>) => {
+  return withExponentialBackoff(f, isRetryableError, 5, 1000);
+};
+
+export async function getObject(
+  api: CloudflareApi,
+  { bucketName, key }: { bucketName: string; key: string },
+) {
+  return await withRetries(async () => {
+    const response = await api.get(
+      `/accounts/${api.accountId}/r2/buckets/${bucketName}/objects/${key}`,
+      {
+        headers: {
+          "Content-Type": "application/octet-stream",
+          Accept: "application/octet-stream",
+        },
+      },
+    );
+    if (!response.ok && response.status !== 404) {
+      throw await handleApiError(response, "get", "object", key);
+    }
+    return response;
+  });
+}
+
+type PutObjectObject =
+  | ReadableStream
+  | ArrayBuffer
+  | ArrayBufferView
+  | string
+  | Blob;
+
+export async function putObject(
+  api: CloudflareApi,
+  {
+    bucketName,
+    key,
+    object,
+  }: {
+    bucketName: string;
+    key: string;
+    object: PutObjectObject;
+  },
+): Promise<Response> {
+  // Using withExponentialBackoff for reliability
+  return await withRetries(async () => {
+    const response = await api.put(
+      `/accounts/${api.accountId}/r2/buckets/${bucketName}/objects/${key}`,
+      object,
+      {
+        headers: {
+          "Content-Type": "application/octet-stream",
+        },
+      },
+    );
+    if (!response.ok) {
+      await handleApiError(response, "put", "object", key);
+    }
+    return response;
+  });
+}
+
+export async function deleteObject(
+  api: CloudflareApi,
+  { bucketName, key }: { bucketName: string; key: string },
+) {
+  return await withRetries(async () => {
+    const response = await api.delete(
+      `/accounts/${api.accountId}/r2/buckets/${bucketName}/objects/${key}`,
+    );
+
+    if (!response.ok && response.status !== 404) {
+      await handleApiError(response, "delete", "object", key);
+    }
+
+    return response;
+  });
+}

package/src/cloudflare/bundle/internal-worker-bundle.ts

@@ -7,7 +7,8 @@ import type { WorkerBundle } from "../worker-bundle.ts";
 export type InternalWorker =
   | "cloudflare-state-store"
   | "dofs-state-store"
-  | "remote-binding-proxy";
+  | "remote-binding-proxy"
+  | "tunnel-proxy";
 
 export const getInternalWorkerBundle = memoize(async (name: InternalWorker) => {
   const content = await fs.readFile(

package/src/cloudflare/bundle/plugin-wasm.ts

@@ -35,11 +35,11 @@ export function createWasmPlugin() {
         );
 
         // Copy to outdir so it's included in the upload
-        await fs.mkdir(outdir, { recursive: true });
-        await fs.copyFile(
-          path.join(args.resolveDir, name),
-          path.join(outdir, name),
-        );
+        const copyFrom = path.join(args.resolveDir, name);
+        const copyTo = path.join(outdir, name);
+        await fs.mkdir(path.dirname(copyTo), { recursive: true });
+        await fs.copyFile(copyFrom, copyTo);
+
         modules.set(args.path, {
           type: "wasm",
           path: name,