alchemy 0.45.6 → 0.46.0

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,

package/src/cloudflare/worker-metadata.ts

@@ -1,6 +1,7 @@
 import { assertNever } from "../util/assert-never.ts";
 import { logger } from "../util/logger.ts";
 import { memoize } from "../util/memoize.ts";
+import { extractCloudflareResult } from "./api-response.ts";
 import type { CloudflareApi } from "./api.ts";
 import {
   Self,
@@ -200,7 +201,7 @@ export interface WorkerMetadata {
 
 export async function prepareWorkerMetadata(
   api: CloudflareApi,
-  props: WorkerProps & {
+  props: Omit<WorkerProps, "entrypoint"> & {
     compatibilityDate: string;
     compatibilityFlags: string[];
     workerName: string;
@@ -210,6 +211,7 @@ export async function prepareWorkerMetadata(
       keepAssets?: boolean;
       assetConfig?: AssetsConfig;
     };
+    tags?: string[];
     unstable_cacheWorkerSettings?: boolean;
   },
 ): Promise<WorkerMetadata> {
@@ -226,7 +228,7 @@ export async function prepareWorkerMetadata(
   // we use Cloudflare Worker tags to store a mapping between Alchemy's stable identifier and the binding name
   // e.g.
   // {
-  //   BINDING_NAME: new DurableObjectNamespace("stable-id")
+  //   BINDING_NAME: DurableObjectNamespace("stable-id")
   // }
   // will be stored as alchemy:do:stable-id:BINDING_NAME
   // TODO(sam): should we base64 encode to ensure no `:` collision risk?
@@ -323,6 +325,7 @@ export async function prepareWorkerMetadata(
       ),
       // encode the migraiton tag if there is one so we can avoid the failed PutWorker after adoption
       ...(newMigrationTag ? [`alchemy:migration-tag:${newMigrationTag}`] : []),
+      ...(props.tags ?? []),
     ],
     migrations: {
       old_tag: oldMigrationTag,
@@ -640,6 +643,7 @@ interface WorkerSettings {
   compatibility_date: string;
   compatibility_flags: string[];
   migrations: SingleStepMigration | MultiStepMigration;
+  tags: string[];
   [key: string]: any;
 }
 
@@ -648,51 +652,22 @@ const getWorkerSettingsWithCache = memoize(
   (api, workerName) => `${api.accountId}:${workerName}`,
 );
 
-async function getWorkerSettings(
+export async function getWorkerSettings(
   api: CloudflareApi,
   workerName: string,
 ): Promise<WorkerSettings | undefined> {
   // Fetch the bindings for a worker by calling the Cloudflare API endpoint:
   // GET /accounts/:account_id/workers/scripts/:script_name/bindings
   // See: https://developers.cloudflare.com/api/resources/workers/subresources/scripts/subresources/script_and_version_settings/methods/get/
-  const response = await api.get(
-    `/accounts/${api.accountId}/workers/scripts/${workerName}/settings`,
-  );
-  if (response.status === 404) {
-    return undefined;
-  }
-  if (!response.ok) {
-    throw new Error(
-      `Error getting worker bindings: ${response.status} ${response.statusText}`,
-    );
-  }
-  // The result is an object with a "result" property containing the bindings array
-  const { result, success, errors } = (await response.json()) as {
-    result: {
-      bindings: WorkerBindingSpec[];
-      compatibility_date: string;
-      compatibility_flags: string[];
-      migrations: SingleStepMigration | MultiStepMigration;
-      [key: string]: any;
-    };
-    success: boolean;
-    errors: Array<{
-      code: number;
-      message: string;
-      documentation_url: string;
-      [key: string]: any;
-    }>;
-    messages: Array<{
-      code: number;
-      message: string;
-      documentation_url: string;
-      [key: string]: any;
-    }>;
-  };
-  if (!success) {
-    throw new Error(
-      `Error getting worker bindings: ${response.status} ${response.statusText}\nErrors:\n${errors.map((e) => `- [${e.code}] ${e.message} (${e.documentation_url})`).join("\n")}`,
-    );
-  }
-  return result;
+  return await extractCloudflareResult<WorkerSettings>(
+    `get worker settings for ${workerName}`,
+    api.get(
+      `/accounts/${api.accountId}/workers/scripts/${workerName}/settings`,
+    ),
+  ).catch((error) => {
+    if (error.status === 404) {
+      return undefined;
+    }
+    throw error;
+  });
 }