alchemy 0.65.1 → 0.67.0

package/src/cloudflare/bucket.ts

@@ -388,7 +388,7 @@ const _R2Bucket = Resource(
     if (this.phase === "delete") {
       if (props.delete !== false) {
         if (this.output.dev?.id) {
-          await deleteMiniflareBinding("r2", this.output.dev.id);
+          await deleteMiniflareBinding(this.scope, "r2", this.output.dev.id);
         }
         if (props.empty) {
           await emptyBucket(api, bucketName, props);

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/cloudflare-env-proxy.ts

@@ -1,7 +1,7 @@
 import type { GetPlatformProxyOptions } from "wrangler";
 import {
-  DEFAULT_CONFIG_PATH,
-  DEFAULT_PERSIST_PATH,
+  getDefaultConfigPath,
+  getDefaultPersistPath,
   validateConfigPath,
   validatePersistPath,
 } from "./miniflare/paths.ts";
@@ -26,7 +26,7 @@ export const getPlatformProxyOptions = (
             typeof input.persist === "object" &&
               typeof input.persist.path === "string"
               ? input.persist.path
-              : DEFAULT_PERSIST_PATH,
+              : getDefaultPersistPath(),
           ),
         };
   if (!persist) {
@@ -39,12 +39,12 @@ export const getPlatformProxyOptions = (
   }
   return {
     ...input,
-    configPath: validateConfigPath(input.configPath ?? DEFAULT_CONFIG_PATH),
+    configPath: validateConfigPath(input.configPath ?? getDefaultConfigPath()),
     persist,
     experimental: (input as any).experimental ?? {
       remoteBindings: true,
     },
-  } as any;
+  };
 };
 
 const warned = new Set<string>();

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-06";
+export const DEFAULT_COMPATIBILITY_DATE = "2025-09-13";

package/src/cloudflare/d1-database.ts

@@ -283,6 +283,7 @@ const _D1Database = Resource(
           databaseId: dev.id,
           migrationsTable: props.migrationsTable ?? DEFAULT_MIGRATIONS_TABLE,
           migrations: props.migrationsFiles,
+          rootDir: this.scope.rootDir,
         });
       }
       return this({
@@ -301,7 +302,7 @@ const _D1Database = Resource(
 
     if (this.phase === "delete") {
       if (this.output.dev?.id) {
-        await deleteMiniflareBinding("d1", this.output.dev.id);
+        await deleteMiniflareBinding(this.scope, "d1", this.output.dev.id);
       }
       if (props.delete !== false && this.output?.id) {
         await deleteDatabase(api, this.output.id);

package/src/cloudflare/d1-local-migrations.ts

@@ -1,7 +1,8 @@
 import * as mf from "miniflare";
-import path from "node:path";
+import { getDefaultPersistPath } from "./miniflare/paths.ts";
 
 export interface D1LocalMigrationOptions {
+  rootDir: string;
   databaseId: string;
   migrationsTable: string;
   migrations: { id: string; sql: string }[];
@@ -13,15 +14,16 @@ export const applyLocalD1Migrations = async (
   const miniflare = new mf.Miniflare({
     script: "",
     modules: true,
-    defaultPersistRoot: path.join(process.cwd(), ".alchemy/miniflare/v3"), // vite plugin forces /v3 suffix
+    defaultPersistRoot: getDefaultPersistPath(options.rootDir),
     d1Persist: true,
     d1Databases: { DB: options.databaseId },
     log: process.env.DEBUG ? new mf.Log(mf.LogLevel.DEBUG) : undefined,
   });
   try {
     await miniflare.ready;
-    const db: D1Database = await miniflare.getD1Database("DB");
-    const session: D1DatabaseSession = db.withSession("first-primary");
+    // TODO(sam): don't use `any` once prisma is fixed upstream
+    const db: any = await miniflare.getD1Database("DB");
+    const session: any = db.withSession("first-primary");
     await session
       .prepare(
         `CREATE TABLE IF NOT EXISTS ${options.migrationsTable} (
@@ -31,11 +33,13 @@ export const applyLocalD1Migrations = async (
     )`,
       )
       .run();
-    const appliedMigrations = await session
+    const appliedMigrations: {
+      results: { name: string }[];
+    } = await session
       .prepare(
         `SELECT name FROM ${options.migrationsTable} ORDER BY applied_at ASC`,
       )
-      .all<{ name: string }>();
+      .all();
     const insertRecord = session.prepare(
       `INSERT INTO ${options.migrationsTable} (name) VALUES (?)`,
     );

package/src/cloudflare/hyperdrive-ref.ts

@@ -0,0 +1,98 @@
+import { alchemy } from "../alchemy.ts";
+import type { Secret } from "../secret.ts";
+import { handleApiError } from "./api-error.ts";
+import {
+  createCloudflareApi,
+  type CloudflareApi,
+  type CloudflareApiOptions,
+} from "./api.ts";
+
+export interface HyperdriveRefProps extends CloudflareApiOptions {
+  name?: string;
+  id?: string;
+  dev?: {
+    origin: string | Secret;
+  };
+}
+
+export type HyperdriveRef = {
+  type: "hyperdrive";
+  name: string;
+  hyperdriveId: string;
+  dev?: {
+    origin: Secret;
+  };
+};
+
+export async function HyperdriveRef(
+  props: HyperdriveRefProps,
+): Promise<HyperdriveRef> {
+  const api = await createCloudflareApi(props);
+
+  let hyperdriveId = props.id;
+  let hyperdriveName = props.name;
+
+  if (!hyperdriveId && hyperdriveName) {
+    // Find hyperdrive by name
+    hyperdriveId = await findHyperdriveIdByName(api, hyperdriveName);
+    if (!hyperdriveId) {
+      throw new Error(
+        `Hyperdrive config with name "${hyperdriveName}" not found`,
+      );
+    }
+  } else if (!hyperdriveName && hyperdriveId) {
+    throw new Error("HyperdriveRef requires either name or both name and id");
+  } else if (!hyperdriveName && !hyperdriveId) {
+    throw new Error("HyperdriveRef requires at least a name");
+  }
+
+  return {
+    type: "hyperdrive",
+    name: hyperdriveName!,
+    hyperdriveId: hyperdriveId!,
+    dev: props.dev
+      ? {
+          origin:
+            typeof props.dev.origin === "string"
+              ? alchemy.secret(props.dev.origin)
+              : props.dev.origin,
+        }
+      : undefined,
+  };
+}
+
+/**
+ * Find a Hyperdrive configuration by name
+ */
+export async function findHyperdriveIdByName(
+  api: CloudflareApi,
+  name: string,
+  page = 1,
+): Promise<string | undefined> {
+  const response = await api.get(
+    `/accounts/${api.accountId}/hyperdrive/configs?page=${page}`,
+  );
+
+  if (!response.ok) {
+    await handleApiError(response, "list", "hyperdrive", "all");
+  }
+
+  const data: {
+    result: Array<{
+      id: string;
+      name: string;
+    }>;
+    result_info?: { total_pages?: number };
+  } = await response.json();
+
+  const found = data.result.find((config) => config.name === name);
+  if (found) {
+    return found.id;
+  }
+
+  if (data.result_info?.total_pages && page < data.result_info.total_pages) {
+    return await findHyperdriveIdByName(api, name, page + 1);
+  }
+
+  return undefined;
+}

package/src/cloudflare/index.ts

@@ -30,6 +30,7 @@ export * from "./email-address.ts";
 export * from "./email-catch-all.ts";
 export * from "./email-routing.ts";
 export * from "./email-rule.ts";
+export * from "./hyperdrive-ref.ts";
 export * from "./hyperdrive.ts";
 export * from "./images.ts";
 export * from "./kv-namespace.ts";
@@ -49,6 +50,7 @@ export * from "./route.ts";
 export * from "./rule.ts";
 export * from "./ruleset.ts";
 export * from "./secret-key.ts";
+export * from "./secret-ref.ts";
 export * from "./secret.ts";
 export * from "./secrets-store.ts";
 export * from "./state.ts";

package/src/cloudflare/kv-namespace.ts

@@ -240,7 +240,7 @@ const _KVNamespace = Resource(
 
     if (this.phase === "delete") {
       if (this.output.dev?.id) {
-        await deleteMiniflareBinding("kv", this.output.dev.id);
+        await deleteMiniflareBinding(this.scope, "kv", this.output.dev.id);
       }
       if (this.output.namespaceId && props.delete !== false) {
         await deleteKVNamespace(api, this.output.namespaceId);

package/src/cloudflare/miniflare/build-worker-options.ts

@@ -2,12 +2,11 @@ import * as miniflare from "miniflare";
 import { assertNever } from "../../util/assert-never.ts";
 import type { HTTPServer } from "../../util/http.ts";
 import type { CloudflareApi } from "../api.ts";
-import {
-  Self,
-  type Binding,
-  type Bindings,
-  type WorkerBindingService,
-  type WorkerBindingSpec,
+import type {
+  Binding,
+  Bindings,
+  WorkerBindingService,
+  WorkerBindingSpec,
 } from "../bindings.ts";
 import { isQueueEventSource, type EventSource } from "../event-source.ts";
 import type { WorkerBundle, WorkerBundleSource } from "../worker-bundle.ts";
@@ -25,11 +24,11 @@ export interface MiniflareWorkerInput {
   assets: AssetsConfig | undefined;
   bundle: WorkerBundleSource;
   port: number | undefined;
+  tunnel: boolean | undefined;
 }
 
 type RemoteOnlyBindingType =
   | "ai"
-  | "ai_gateway"
   | "browser"
   | "dispatch_namespace"
   | "mtls_certificate"
@@ -92,13 +91,18 @@ export const buildWorkerOptions = async (
       (options.bindings ??= {})[key] = binding;
       continue;
     }
-    if (binding === Self) {
+    if (binding.type === "cloudflare::Worker::Self") {
       (options.serviceBindings ??= {})[key] = miniflare.kCurrentWorker;
       continue;
     }
     switch (binding.type) {
-      case "ai":
-      case "ai_gateway": {
+      case "ai": {
+        const existing = remoteBindings.find((b) => b.type === "ai");
+        if (existing) {
+          throw new Error(
+            `Workers cannot have multiple AI bindings. Binding "${key}" conflicts with "${existing.name}".`,
+          );
+        }
         remoteBindings.push({
           type: "ai",
           name: key,
@@ -180,7 +184,9 @@ export const buildWorkerOptions = async (
         break;
       }
       case "hyperdrive": {
-        (options.hyperdrives ??= {})[key] = binding.dev.origin.unencrypted;
+        if (binding.dev) {
+          (options.hyperdrives ??= {})[key] = binding.dev.origin.unencrypted;
+        }
         break;
       }
       case "images": {
@@ -459,7 +465,10 @@ const normalizeBundle = (bundle: WorkerBundle) => {
 };
 
 const isRemoteBinding = (binding: Binding) => {
-  if (typeof binding === "string" || binding === Self) {
+  if (
+    typeof binding === "string" ||
+    binding.type === "cloudflare::Worker::Self"
+  ) {
     return false;
   }
   return (

package/src/cloudflare/miniflare/delete.ts

@@ -2,11 +2,11 @@ import crypto from "node:crypto";
 import type { RmDirOptions } from "node:fs";
 import fs from "node:fs/promises";
 import path from "pathe";
+import type { Scope } from "../../scope.ts";
 import type { DurableObjectNamespace } from "../durable-object-namespace.ts";
 import type { Workflow } from "../workflow.ts";
-import { DEFAULT_PERSIST_PATH } from "./paths.ts";
+import { getDefaultPersistPath } from "./paths.ts";
 
-const PERSIST_ROOT = path.resolve(DEFAULT_PERSIST_PATH);
 const BINDING_TYPE_KEY = {
   d1: "miniflare-D1DatabaseObject",
   kv: "miniflare-KVNamespaceObject",
@@ -18,8 +18,14 @@ type BindingType = keyof typeof BINDING_TYPE_KEY;
 /**
  * Delete a binding from the miniflare directory.
  */
-export async function deleteMiniflareBinding(type: BindingType, id: string) {
-  const bindingPath = path.join(PERSIST_ROOT, type, BINDING_TYPE_KEY[type]);
+export async function deleteMiniflareBinding(
+  scope: Scope,
+  type: BindingType,
+  id: string,
+) {
+  const persistRoot = path.resolve(getDefaultPersistPath(scope.rootDir));
+
+  const bindingPath = path.join(persistRoot, type, BINDING_TYPE_KEY[type]);
 
   // delete durable object/sqlite files
   const namespaceId = durableObjectNamespaceIdFromName(
@@ -33,29 +39,31 @@ export async function deleteMiniflareBinding(type: BindingType, id: string) {
   await Promise.all(files.map((file) => fs.rm(path.join(bindingPath, file))));
 
   // delete data directory, if present
-  await removeDirectory(path.join(PERSIST_ROOT, type, id), {
+  await removeDirectory(path.join(persistRoot, type, id), {
     recursive: true,
   });
 
   // delete the miniflare directory if it is empty
-  await cleanMiniflareDirectory();
+  await cleanMiniflareDirectory(scope.dotAlchemy);
 }
 
 /**
  * Delete local durable object and workflow data for a given Worker script.
  */
 export async function deleteMiniflareWorkerData(
+  scope: Scope,
   scriptName: string,
   input: {
     durableObjects: DurableObjectNamespace[];
     workflows: Workflow[];
   },
 ) {
+  const persistRoot = path.resolve(getDefaultPersistPath(scope.rootDir));
   await Promise.all(
     input.durableObjects.map((durableObject) =>
       removeDirectory(
         path.join(
-          PERSIST_ROOT,
+          persistRoot,
           "do",
           `${scriptName}-${durableObject.className}`,
         ),
@@ -69,7 +77,7 @@ export async function deleteMiniflareWorkerData(
     input.workflows.map((workflow) =>
       removeDirectory(
         path.join(
-          PERSIST_ROOT,
+          persistRoot,
           "workflows",
           `miniflare-workflows-${workflow.workflowName}`,
         ),
@@ -79,14 +87,14 @@ export async function deleteMiniflareWorkerData(
       ),
     ),
   );
-  await cleanMiniflareDirectory();
+  await cleanMiniflareDirectory(persistRoot);
 }
 
 /**
  * Delete the miniflare directory iff it is empty.
  */
-async function cleanMiniflareDirectory() {
-  const directory = path.resolve(".alchemy/miniflare");
+async function cleanMiniflareDirectory(dotAlchemy: string) {
+  const directory = path.resolve(dotAlchemy, "miniflare");
   const files = await fs
     .readdir(directory, {
       recursive: true,

package/src/cloudflare/miniflare/miniflare-controller.ts

@@ -1,6 +1,7 @@
 import * as miniflare from "miniflare";
 import assert from "node:assert";
 import path from "node:path";
+import { Scope } from "../../scope.ts";
 import { findOpenPort } from "../../util/find-open-port.ts";
 import type { HTTPServer } from "../../util/http.ts";
 import { logger } from "../../util/logger.ts";
@@ -9,8 +10,12 @@ import {
   buildWorkerOptions,
   type MiniflareWorkerInput,
 } from "./build-worker-options.ts";
-import { MiniflareWorkerProxy } from "./miniflare-worker-proxy.ts";
-import { DEFAULT_PERSIST_PATH } from "./paths.ts";
+import {
+  createMiniflareWorkerProxy,
+  type MiniflareWorkerProxy,
+} from "./miniflare-worker-proxy.ts";
+import { getDefaultPersistPath } from "./paths.ts";
+import { createTunnel, type Tunnel } from "./tunnel.ts";
 
 declare global {
   var ALCHEMY_MINIFLARE_CONTROLLER: MiniflareController | undefined;
@@ -20,13 +25,14 @@ export class MiniflareController {
   abort = new AbortController();
   miniflare: miniflare.Miniflare | undefined;
   options = new Map<string, miniflare.WorkerOptions>();
+  tunnel: Tunnel | undefined;
   localProxies = new Map<string, MiniflareWorkerProxy>();
   remoteProxies = new Map<string, HTTPServer>();
   mutex = new AsyncMutex();
 
   static get singleton() {
-    globalThis.ALCHEMY_MINIFLARE_CONTROLLER ??= new MiniflareController();
-    return globalThis.ALCHEMY_MINIFLARE_CONTROLLER;
+    return (globalThis.ALCHEMY_MINIFLARE_CONTROLLER ??=
+      new MiniflareController());
   }
 
   async add(input: MiniflareWorkerInput) {
@@ -39,21 +45,32 @@ export class MiniflareController {
     assert(first.value, "First value is undefined");
     this.options.set(input.name, first.value);
     const miniflare = await this.update();
-    const proxy = new MiniflareWorkerProxy({
-      name: input.name,
-      port: input.port ?? (await findOpenPort()),
-      miniflare,
-    });
-    this.localProxies.set(input.name, proxy);
+    let url: URL;
+    if (input.tunnel) {
+      this.tunnel ??= await createTunnel(miniflare);
+      url = await this.tunnel.configureWorker({
+        api: input.api,
+        name: input.name,
+      });
+    } else {
+      const proxy = await createMiniflareWorkerProxy({
+        port: input.port ?? (await findOpenPort()),
+        getWorkerName: () => input.name,
+        miniflare,
+        mode: "local",
+      });
+      this.localProxies.set(input.name, proxy);
+      url = proxy.url;
+    }
     void this.watch(input.id, watcher);
     logger.task(input.id, {
-      message: `Ready at ${proxy.url}`,
+      message: `Ready at ${url}`,
       status: "success",
       resource: input.id,
       prefix: "dev",
       prefixColor: "cyanBright",
     });
-    return proxy.url;
+    return url.toString();
   }
 
   private async watch(
@@ -77,12 +94,13 @@ export class MiniflareController {
     return await this.mutex.lock(async () => {
       const options: miniflare.MiniflareOptions = {
         workers: [],
-        defaultPersistRoot: path.resolve(DEFAULT_PERSIST_PATH),
+        defaultPersistRoot: path.resolve(
+          getDefaultPersistPath(Scope.current.rootDir),
+        ),
         unsafeDevRegistryPath: miniflare.getDefaultDevRegistryPath(),
         log: process.env.DEBUG
           ? new miniflare.Log(miniflare.LogLevel.DEBUG)
           : undefined,
-
         // This is required to allow websites and other separate processes
         // to detect Alchemy-managed Durable Objects via the Wrangler dev registry.
         unsafeDevRegistryDurableObjectProxy: true,
@@ -143,6 +161,7 @@ export class MiniflareController {
     this.abort.abort();
     await Promise.all([
       this.miniflare?.dispose(),
+      this.tunnel?.close(),
       ...this.localProxies.values().map((proxy) => proxy.close()),
       ...this.remoteProxies.values().map((proxy) => proxy.close()),
     ]);