alchemy 0.45.5 → 0.46.0

package/src/cloudflare/images.ts

@@ -1,5 +1,25 @@
 /**
- * Cloudflare Images binding for image transformation and manipulation.
+ * Properties for creating an Images binding
+ */
+export interface ImagesProps {
+  dev?: {
+    /**
+     * Whether to run the images binding remotely instead of locally
+     * @default false
+     */
+    remote?: boolean;
+  };
+}
+
+export type Images = {
+  type: "images";
+  dev?: {
+    remote?: boolean;
+  };
+};
+
+/**
+ * Creates a Cloudflare Images binding for image transformation and manipulation.
  *
  * Provides access to Cloudflare Images API for transforming, drawing, and outputting images
  * within Workers. The binding requires no configuration - just the binding name.
@@ -9,10 +29,11 @@
  * - For deployed Workers: image transforms must be enabled for the zone
  *
  * @example
+ * ```ts
  * // Create an Images binding and bind to a Worker:
  * import { Worker, Images } from "alchemy/cloudflare";
  *
- * const images = new Images();
+ * const images = Images();
  *
  * const worker = await Worker("image-processor", {
  *   name: "image-processor",
@@ -21,8 +42,10 @@
  *     IMAGES: images
  *   }
  * });
+ * ```
  *
  * @example
+ * ```ts
  * // Runtime usage - Basic image transformation:
  * export default {
  *   async fetch(request: Request, env: any): Promise<Response> {
@@ -36,8 +59,10 @@
  *     return response.response();
  *   }
  * };
+ * ```
  *
  * @example
+ * ```ts
  * // Runtime usage - Advanced transformations with overlays:
  * const watermark: ReadableStream = await fetchWatermark();
  * const image: ReadableStream = await fetchMainImage();
@@ -51,23 +76,13 @@
  *   .output({ format: "image/avif" });
  *
  * return response.response();
+ * ```
  *
  * @see https://developers.cloudflare.com/images/transform-images/bindings/
  */
-export class Images {
-  public readonly type = "images";
-  public readonly dev?: {
-    remote?: boolean;
+export function Images(props?: ImagesProps): Images {
+  return {
+    type: "images",
+    dev: props?.dev,
   };
-  constructor(props?: {
-    dev?: {
-      /**
-       * Whether to run the images binding remotely instead of locally
-       * @default false
-       */
-      remote?: boolean;
-    };
-  }) {
-    this.dev = props?.dev;
-  }
 }

package/src/cloudflare/index.ts

@@ -18,10 +18,8 @@ export * from "./d1-clone.ts";
 export * from "./d1-database.ts";
 export * from "./d1-export.ts";
 export * from "./d1-import.ts";
-export * from "./d1-state-store.ts";
 export * from "./dispatch-namespace.ts";
 export * from "./dns-records.ts";
-export * from "./do-state-store/index.ts";
 export * from "./durable-object-namespace.ts";
 export * from "./email-address.ts";
 export * from "./email-catch-all.ts";
@@ -37,7 +35,6 @@ export * from "./permission-groups.ts";
 export * from "./pipeline.ts";
 export * from "./queue-consumer.ts";
 export * from "./queue.ts";
-export * from "./r2-rest-state-store.ts";
 export * from "./react-router.ts";
 export * from "./redirect-rule.ts";
 export * from "./redwood.ts";
@@ -45,6 +42,7 @@ export * from "./route.ts";
 export * from "./secret-key.ts";
 export * from "./secret.ts";
 export * from "./secrets-store.ts";
+export * from "./state.ts";
 export * from "./sveltekit.ts";
 export * from "./tanstack-start.ts";
 export * from "./vectorize-index.ts";

package/src/cloudflare/miniflare/miniflare.ts

@@ -7,24 +7,27 @@ import {
 } from "miniflare";
 import path from "node:path";
 import { findOpenPort } from "../../util/find-open-port.ts";
+import { HTTPServer } from "../../util/http-server.ts";
 import { logger } from "../../util/logger.ts";
 import {
   promiseWithResolvers,
   type PromiseWithResolvers,
 } from "../../util/promise-with-resolvers.ts";
-import { HTTPServer } from "./http-server.ts";
 import {
   buildMiniflareWorkerOptions,
   buildRemoteBindings,
   type MiniflareWorkerOptions,
 } from "./miniflare-worker-options.ts";
-import { createMixedModeProxy, type MixedModeProxy } from "./mixed-mode.ts";
+import {
+  createRemoteProxyWorker,
+  type RemoteBindingProxy,
+} from "./remote-binding-proxy.ts";
 
 class MiniflareServer {
   miniflare?: Miniflare;
   workers = new Map<string, WorkerOptions>();
   servers = new Map<string, HTTPServer>();
-  mixedModeProxies = new Map<string, MixedModeProxy>();
+  remoteBindingProxies = new Map<string, RemoteBindingProxy>();
 
   stream = new WritableStream<{
     worker: MiniflareWorkerOptions;
@@ -104,7 +107,7 @@ class MiniflareServer {
     await Promise.all([
       this.miniflare?.dispose(),
       ...Array.from(this.servers.values()).map((server) => server.stop()),
-      ...Array.from(this.mixedModeProxies.values()).map((proxy) =>
+      ...Array.from(this.remoteBindingProxies.values()).map((proxy) =>
         proxy.server.stop(),
       ),
     ]);
@@ -120,7 +123,7 @@ class MiniflareServer {
     if (bindings.length === 0) {
       return undefined;
     }
-    const existing = this.mixedModeProxies.get(worker.name);
+    const existing = this.remoteBindingProxies.get(worker.name);
     if (
       existing?.bindings.every((b) =>
         bindings.find((b2) => b2.name === b.name && b2.type === b.type),
@@ -128,11 +131,11 @@ class MiniflareServer {
     ) {
       return existing.connectionString;
     }
-    const proxy = await createMixedModeProxy({
+    const proxy = await createRemoteProxyWorker({
       name: `mixed-mode-proxy-${crypto.randomUUID()}`,
       bindings,
     });
-    this.mixedModeProxies.set(worker.name, proxy);
+    this.remoteBindingProxies.set(worker.name, proxy);
     return proxy.connectionString;
   }
 

package/src/cloudflare/miniflare/{mixed-mode.ts → remote-binding-proxy.ts}

@@ -1,10 +1,10 @@
 import type { RemoteProxyConnectionString } from "miniflare";
+import { HTTPServer } from "../../util/http-server.ts";
+import { extractCloudflareResult } from "../api-response.ts";
 import { createCloudflareApi, type CloudflareApi } from "../api.ts";
 import type { WorkerBindingSpec } from "../bindings.ts";
-import type { CloudflareApiResponse } from "../types.ts";
+import { getInternalWorkerBundle } from "../bundle/internal-worker-bundle.ts";
 import type { WorkerMetadata } from "../worker-metadata.ts";
-import { getAccountSubdomain, getWorkerTemplate } from "../worker/shared.ts";
-import { HTTPServer } from "./http-server.ts";
 
 type WranglerSessionConfig =
   | {
@@ -22,41 +22,39 @@ interface WorkersPreviewSession {
   token: string;
 }
 
-export async function createMixedModeProxy(input: {
+export async function createRemoteProxyWorker(input: {
   name: string;
   bindings: WorkerBindingSpec[];
 }) {
   const api = await createCloudflareApi();
-  const script = await getWorkerTemplate("mixed-mode-proxy-worker");
+  const script = await getInternalWorkerBundle("remote-binding-proxy");
   const [token, subdomain] = await Promise.all([
     createWorkersPreviewToken(api, {
       name: input.name,
       metadata: {
-        main_module: script.name,
+        main_module: script.file.name,
         compatibility_date: "2025-06-16",
         bindings: input.bindings,
         observability: {
           enabled: false,
         },
       },
-      files: [script],
+      files: [script.file],
       session: {
         workers_dev: true,
         minimal_mode: true,
       },
     }),
-    getAccountSubdomain(api),
+    import("../worker-subdomain.ts").then((m) => m.getAccountSubdomain(api)),
   ]);
-  return new MixedModeProxy(
+  return new RemoteBindingProxy(
     `https://${input.name}.${subdomain}.workers.dev`,
     token,
     input.bindings,
   );
 }
 
-const DEBUG: boolean = false;
-
-export class MixedModeProxy {
+export class RemoteBindingProxy {
   server: HTTPServer;
 
   constructor(
@@ -100,27 +98,6 @@ export class MixedModeProxy {
     responseHeaders.delete("transfer-encoding");
     responseHeaders.delete("content-encoding");
 
-    if (DEBUG) {
-      const clone = res.clone();
-      console.log({
-        request: {
-          url: url.toString(),
-          method: req.method,
-          headers,
-          body: req.body,
-        },
-        response: {
-          status: res.status,
-          headers: res.headers,
-          body: await res.text(),
-        },
-      });
-      return new Response(clone.body, {
-        status: clone.status,
-        headers: responseHeaders,
-      });
-    }
-
     return new Response(res.body, {
       status: res.status,
       headers: responseHeaders,
@@ -144,8 +121,9 @@ async function createWorkersPreviewToken(
     formData.append(file.name, file);
   }
   formData.append("wrangler-session-config", JSON.stringify(input.session));
-  const res = await api
-    .post(
+  const res = await extractCloudflareResult<{ preview_token: string }>(
+    "create workers preview token",
+    api.post(
       `/accounts/${api.accountId}/workers/scripts/${input.name}/edge-preview`,
       formData,
       {
@@ -153,13 +131,8 @@ async function createWorkersPreviewToken(
           "cf-preview-upload-config-token": session.token,
         },
       },
-    )
-    .then((res) =>
-      parseCloudflareResponse<{ preview_token: string }>(
-        res,
-        "Failed to create workers preview token",
-      ),
-    );
+    ),
+  );
   // Fire and forget prewarm call
   // (see https://github.com/cloudflare/workers-sdk/blob/6c6afbd6072b96e78e67d3a863ed849c6aa49472/packages/wrangler/src/dev/create-worker-preview.ts#L338)
   void prewarm(session.prewarm, res.preview_token);
@@ -178,42 +151,19 @@ async function prewarm(url: string, previewToken: string) {
 }
 
 async function createWorkersPreviewSession(api: CloudflareApi) {
-  const { exchange_url } = await api
-    .get(`/accounts/${api.accountId}/workers/subdomain/edge-preview`)
-    .then((res) =>
-      parseCloudflareResponse<{
-        exchange_url: string;
-        token: string;
-      }>(res, "Failed to create workers preview session"),
-    );
-  return await fetch(exchange_url).then((res) =>
-    parseResponse<WorkersPreviewSession>(
-      res,
-      "Failed to create workers preview session",
-    ),
+  const { exchange_url } = await extractCloudflareResult<{
+    exchange_url: string;
+    token: string;
+  }>(
+    "create workers preview session",
+    api.get(`/accounts/${api.accountId}/workers/subdomain/edge-preview`),
   );
-}
-
-async function parseResponse<T>(res: Response, message: string): Promise<T> {
+  const res = await fetch(exchange_url);
   if (!res.ok) {
-    throw new Error(`${message} (${res.status} ${res.statusText})`);
-  }
-  const json: T = await res.json();
-  return json;
-}
-
-async function parseCloudflareResponse<T>(
-  res: Response,
-  message: string,
-): Promise<T> {
-  const json: CloudflareApiResponse<T> = await res.json();
-  if (!json.success) {
     throw new Error(
-      `${message} (${res.status} ${res.statusText} - ${json.errors.map((e) => `${e.code}: ${e.message}`).join(", ")})`,
+      `Failed to create workers preview session: ${res.status} ${res.statusText}`,
     );
   }
-  if (!json.result) {
-    throw new Error(`${message} (${res.status} ${res.statusText})`);
-  }
-  return json.result;
+  const json: WorkersPreviewSession = await res.json();
+  return json;
 }

package/src/cloudflare/state.ts

@@ -0,0 +1,35 @@
+import {
+  D1StateStore as _D1StateStore,
+  DOFSStateStore as _DOFSStateStore,
+  R2RestStateStore as _R2RestStateStore,
+} from "../state/index.ts";
+
+/**
+ * @deprecated Use `R2RestStateStore` from `alchemy/state` instead.
+ */
+export const R2RestStateStore = _R2RestStateStore;
+
+/**
+ * @deprecated Use `R2RestStateStore` from `alchemy/state` instead.
+ */
+export type R2RestStateStore = _R2RestStateStore;
+
+/**
+ * @deprecated This state store is no longer recommended for production use. Please use {@link https://alchemy.run/guides/cloudflare-state-store/ CloudflareStateStore} from `alchemy/state` instead.
+ */
+export const DOStateStore = _DOFSStateStore;
+
+/**
+ * @deprecated Use `DOStateStore` from `alchemy/state` instead.
+ */
+export type DOStateStore = _DOFSStateStore;
+
+/**
+ * @deprecated Use `D1StateStore` from `alchemy/state` instead.
+ */
+export const D1StateStore = _D1StateStore;
+
+/**
+ * @deprecated Use `D1StateStore` from `alchemy/state` instead.
+ */
+export type D1StateStore = _D1StateStore;

package/src/cloudflare/user.ts

@@ -1,5 +1,6 @@
 import type { Secret } from "../secret.ts";
 import { logger } from "../util/logger.ts";
+import { memoize } from "../util/memoize.ts";
 import { CloudflareApiError } from "./api-error.ts";
 import {
   getCloudflareAuthHeaders,
@@ -55,82 +56,66 @@ export interface CloudflareOrganization {
   roles: string[];
 }
 
-const accountCache: Record<string, CloudflareAccount[]> = {};
-
-export async function getCloudflareAccounts(
-  options: CloudflareAuthOptions,
-): Promise<CloudflareAccount[]> {
-  const cacheKey = JSON.stringify({
-    apiKey: options.apiKey?.unencrypted,
-    apiToken: options.apiToken?.unencrypted,
-    email: options.email,
-  });
-  if (accountCache[cacheKey]) {
-    return accountCache[cacheKey];
-  }
-
-  const headers = await getCloudflareAuthHeaders(options);
-  const accounts = await fetch(
-    "https://api.cloudflare.com/client/v4/accounts",
-    {
-      headers,
-    },
-  );
-
-  if (accounts.ok) {
-    return (accountCache[cacheKey] ??= ((await accounts.json()) as any).result);
-  } else {
-    throw new CloudflareApiError(
-      `Failed to get accounts for authorized user, please make sure you're authenticated (see: https://alchemy.run/guides/cloudflare/) or explicitly set the Cloudflare Account ID (see: https://alchemy.run/guides/cloudflare/#account-id)`,
-      accounts,
+export const getCloudflareAccounts = memoize(
+  async (options: CloudflareAuthOptions): Promise<CloudflareAccount[]> => {
+    const headers = await getCloudflareAuthHeaders(options);
+    const accounts = await fetch(
+      "https://api.cloudflare.com/client/v4/accounts",
+      {
+        headers,
+      },
     );
-  }
-}
+    if (accounts.ok) {
+      return ((await accounts.json()) as any).result;
+    } else {
+      throw new CloudflareApiError(
+        `Failed to get accounts for authorized user, please make sure you're authenticated (see: https://alchemy.run/guides/cloudflare/) or explicitly set the Cloudflare Account ID (see: https://alchemy.run/guides/cloudflare/#account-id)`,
+        accounts,
+      );
+    }
+  },
+);
 
-const emailCache: Record<string, string> = {};
+export const getUserEmailFromApiKey = memoize(
+  async (apiKey: string): Promise<string> => {
+    try {
+      // Call the /user endpoint to get user information
+      const response = await fetch(
+        "https://api.cloudflare.com/client/v4/user",
+        {
+          headers: {
+            "Content-Type": "application/json",
+            "X-Auth-Key": apiKey,
+          },
+        },
+      );
 
-export async function getUserEmailFromApiKey(apiKey: string): Promise<string> {
-  if (emailCache[apiKey]) {
-    return emailCache[apiKey];
-  }
+      if (!response.ok) {
+        throw new Error(
+          `Failed to get user information: ${response.status} ${response.statusText}`,
+        );
+      }
 
-  try {
-    const baseUrl = "https://api.cloudflare.com/client/v4";
+      const data = (await response.json()) as {
+        success: boolean;
+        result: {
+          id: string;
+          email: string;
+          name: string;
+          [key: string]: any;
+        };
+      };
 
-    // Call the /user endpoint to get user information
-    const response = await fetch(`${baseUrl}/user`, {
-      headers: {
-        "Content-Type": "application/json",
-        "X-Auth-Key": apiKey,
-      },
-    });
+      if (!data.success || !data.result || !data.result.email) {
+        throw new Error("Cloudflare API did not return valid user information");
+      }
 
-    if (!response.ok) {
+      return data.result.email;
+    } catch (error) {
+      logger.error("Error retrieving email from Cloudflare API:", error);
       throw new Error(
-        `Failed to get user information: ${response.status} ${response.statusText}`,
+        "Failed to automatically discover email for API Key authentication",
       );
     }
-
-    const data = (await response.json()) as {
-      success: boolean;
-      result: {
-        id: string;
-        email: string;
-        name: string;
-        [key: string]: any;
-      };
-    };
-
-    if (!data.success || !data.result || !data.result.email) {
-      throw new Error("Cloudflare API did not return valid user information");
-    }
-
-    emailCache[apiKey] = data.result.email;
-    return data.result.email;
-  } catch (error) {
-    logger.error("Error retrieving email from Cloudflare API:", error);
-    throw new Error(
-      "Failed to automatically discover email for API Key authentication",
-    );
-  }
-}
+  },
+);

package/src/cloudflare/vectorize-index.ts

@@ -169,7 +169,7 @@ const _VectorizeIndex = Resource(
         if (
           props.adopt &&
           error instanceof CloudflareApiError &&
-          error.message.includes("already exists")
+          error.message.includes("vectorize.index.duplicate_name")
         ) {
           logger.log(`Index ${indexName} already exists, adopting it`);
           // Find the existing index
@@ -321,7 +321,12 @@ export async function deleteIndex(
     `/accounts/${api.accountId}/vectorize/v2/indexes/${indexName}`,
   );
 
-  if (!deleteResponse.ok && deleteResponse.status !== 404) {
+  if (
+    !deleteResponse.ok &&
+    // not 404 (Not Found) or 410 (Gone)
+    deleteResponse.status !== 404 &&
+    deleteResponse.status !== 410
+  ) {
     const errorData: any = await deleteResponse.json().catch(() => ({
       errors: [{ message: deleteResponse.statusText }],
     }));

package/src/cloudflare/version-metadata.ts

@@ -1,6 +1,23 @@
 /**
+ * Type representing a version metadata binding.
  * @see https://developers.cloudflare.com/workers/runtime-apis/bindings/version-metadata/
  */
-export class VersionMetadata {
-  public readonly type = "version_metadata";
+export type VersionMetadata = {
+  type: "version_metadata";
+};
+
+/**
+ * Creates a version metadata binding that provides access to version information at runtime.
+ *
+ * @example
+ * ```ts
+ * const metadata = VersionMetadata();
+ * ```
+ *
+ * @see https://developers.cloudflare.com/workers/runtime-apis/bindings/version-metadata/
+ */
+export function VersionMetadata(): VersionMetadata {
+  return {
+    type: "version_metadata",
+  };
 }

package/src/cloudflare/vite.ts

@@ -18,12 +18,13 @@ export async function Vite<B extends Bindings>(
   props: ViteProps<B>,
 ): Promise<Vite<B>> {
   const defaultAssets = path.join("dist", "client");
-  const packageManager = detectPackageManager();
+  const packageManager = await detectPackageManager();
   const devCommand = {
     npm: "npx vite dev",
     bun: "bun vite dev",
     pnpm: "pnpm vite dev",
     yarn: "yarn vite dev",
+    deno: "deno vite dev",
   }[packageManager];
   return Website(id, {
     ...props,