alchemy 0.48.0 → 0.48.2

package/src/cloudflare/miniflare/miniflare-worker-proxy.ts

@@ -0,0 +1,97 @@
+import type http from "node:http";
+import { WebSocket, WebSocketServer } from "ws";
+import { HTTPServer } from "../../util/http.ts";
+
+export interface MiniflareWorkerProxyOptions {
+  /**
+   * Used to proxy websocket connections to the worker.
+   * (This is a hack; used because trying to interact with `response.webSocket` doesn't work on Bun.)
+   */
+  getDirectURL: () => Promise<URL>;
+  /** Used to proxy HTTP requests to the worker. */
+  fetch: (request: Request) => Promise<Response>;
+}
+
+export class MiniflareWorkerProxy extends HTTPServer {
+  wsServer: WebSocketServer;
+  wsReconnectAttempts = new Map<string, number>();
+
+  constructor(private readonly options: MiniflareWorkerProxyOptions) {
+    super({
+      fetch: options.fetch,
+    });
+    this.wsServer = new WebSocketServer({ noServer: true });
+    this.httpServer.on("upgrade", async (req, socket, head) => {
+      this.wsServer.handleUpgrade(req, socket, head, async (client) => {
+        const id = crypto.randomUUID();
+        await this.handleUpgrade(id, client, req);
+      });
+    });
+  }
+
+  private async handleUpgrade(
+    id: string,
+    client: WebSocket,
+    request: http.IncomingMessage,
+  ) {
+    const attempt = this.wsReconnectAttempts.get(id) ?? 0;
+    this.wsReconnectAttempts.set(id, attempt + 1);
+    if (attempt > 3) {
+      client.close(1006, "Too many reconnect attempts");
+      return;
+    }
+    if (attempt > 0) {
+      const delay = attempt * 1000;
+      await new Promise((resolve) => setTimeout(resolve, delay));
+    }
+
+    const target = await this.options.getDirectURL();
+    const url = new URL(request.url ?? "/", target);
+    const headers = { ...request.headers };
+    // All of these headers are set by the WebSocket constructor,
+    // so if we don't delete them, the request will fail.
+    delete headers.host;
+    delete headers.connection;
+    delete headers.upgrade;
+    delete headers["sec-websocket-version"];
+    delete headers["sec-websocket-key"];
+    delete headers["sec-websocket-protocol"];
+    delete headers["sec-websocket-extensions"];
+    delete headers["sec-websocket-accept"];
+    const server = new WebSocket(url.toString(), {
+      protocol: request.headers["sec-websocket-protocol"],
+      key: request.headers["sec-websocket-key"],
+      headers,
+    });
+    server.on("open", () => {
+      // Reset the reconnect attempts when the connection is established successfully.
+      this.wsReconnectAttempts.set(id, 0);
+    });
+    server.on("message", (data, binary) => {
+      client.send(data, { binary });
+    });
+    server.on("close", async (code, reason) => {
+      if (code === 1006) {
+        // When the worker hot reloads, the websocket connection is closed with this code.
+        // Reconnecting allows the client to maintain the same connection.
+        await this.handleUpgrade(id, client, request);
+        return;
+      }
+      client.close(code, reason);
+    });
+    client.on("message", (data, binary) => {
+      server.send(data, { binary });
+    });
+    client.on("close", (code, reason) => {
+      this.wsReconnectAttempts.delete(id);
+      if (server.readyState === WebSocket.OPEN) {
+        server.close(code, reason);
+      }
+    });
+  }
+
+  async close() {
+    this.wsServer.close();
+    await super.close();
+  }
+}

package/src/cloudflare/miniflare/miniflare.ts

@@ -7,7 +7,6 @@ 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,
@@ -18,6 +17,7 @@ import {
   buildRemoteBindings,
   type MiniflareWorkerOptions,
 } from "./miniflare-worker-options.ts";
+import { MiniflareWorkerProxy } from "./miniflare-worker-proxy.ts";
 import {
   createRemoteProxyWorker,
   type RemoteBindingProxy,
@@ -26,12 +26,12 @@ import {
 class MiniflareServer {
   miniflare?: Miniflare;
   workers = new Map<string, WorkerOptions>();
-  servers = new Map<string, HTTPServer>();
+  workerProxies = new Map<string, MiniflareWorkerProxy>();
   remoteBindingProxies = new Map<string, RemoteBindingProxy>();
 
   stream = new WritableStream<{
     worker: MiniflareWorkerOptions;
-    promise: PromiseWithResolvers<HTTPServer>;
+    promise: PromiseWithResolvers<MiniflareWorkerProxy>;
   }>({
     write: async ({ worker, promise }) => {
       try {
@@ -48,7 +48,7 @@ class MiniflareServer {
   writer = this.stream.getWriter();
 
   async push(worker: MiniflareWorkerOptions) {
-    const promise = promiseWithResolvers<HTTPServer>();
+    const promise = promiseWithResolvers<MiniflareWorkerProxy>();
     const [, server] = await Promise.all([
       this.writer.write({ worker, promise }),
       promise.promise,
@@ -62,11 +62,10 @@ class MiniflareServer {
 
   private async set(worker: MiniflareWorkerOptions) {
     this.workers.set(
-      worker.name as string,
+      worker.name,
       await buildMiniflareWorkerOptions({
         ...worker,
-        remoteProxyConnectionString:
-          await this.maybeCreateMixedModeProxy(worker),
+        remoteProxyConnectionString: await this.maybeCreateRemoteProxy(worker),
       }),
     );
     if (this.miniflare) {
@@ -90,33 +89,41 @@ class MiniflareServer {
       this.miniflare = new Miniflare(await this.miniflareOptions());
       await withErrorRewrite(this.miniflare.ready);
     }
-    const existing = this.servers.get(worker.name);
+    const existing = this.workerProxies.get(worker.name);
     if (existing) {
       return existing;
     }
-    const server = new HTTPServer({
-      port: worker.port ?? (await findOpenPort()),
-      fetch: this.createRequestHandler(worker.name as string),
+    const server = new MiniflareWorkerProxy({
+      getDirectURL: async () => {
+        const url = await this.miniflare?.unsafeGetDirectURL(worker.name);
+        if (!url) {
+          throw new Error(`Worker "${worker.name}" is not running`);
+        }
+        return url;
+      },
+      fetch: this.createRequestHandler(worker.name),
     });
-    this.servers.set(worker.name, server);
-    await server.ready;
+    this.workerProxies.set(worker.name, server);
+    await server.listen(worker.port ?? (await findOpenPort()));
     return server;
   }
 
   private async dispose() {
     await Promise.all([
       this.miniflare?.dispose(),
-      ...Array.from(this.servers.values()).map((server) => server.stop()),
+      ...Array.from(this.workerProxies.values()).map((server) =>
+        server.close(),
+      ),
       ...Array.from(this.remoteBindingProxies.values()).map((proxy) =>
-        proxy.server.stop(),
+        proxy.server.close(),
       ),
     ]);
     this.miniflare = undefined;
     this.workers.clear();
-    this.servers.clear();
+    this.workerProxies.clear();
   }
 
-  private async maybeCreateMixedModeProxy(
+  private async maybeCreateRemoteProxy(
     worker: MiniflareWorkerOptions,
   ): Promise<RemoteProxyConnectionString | undefined> {
     const bindings = buildRemoteBindings(worker);
@@ -130,6 +137,8 @@ class MiniflareServer {
       )
     ) {
       return existing.connectionString;
+    } else if (existing) {
+      await existing.server.close();
     }
     const proxy = await createRemoteProxyWorker({
       name: `mixed-mode-proxy-${crypto.randomUUID()}`,
@@ -150,8 +159,8 @@ class MiniflareServer {
             },
           );
         }
-        const miniflare = await this.miniflare?.getWorker(name);
-        if (!miniflare) {
+        const worker = await this.miniflare?.getWorker(name);
+        if (!worker) {
           return new Response(
             `[Alchemy] Cannot find worker "${name}". Please try again.`,
             {
@@ -159,12 +168,12 @@ class MiniflareServer {
             },
           );
         }
-        const res = await miniflare.fetch(req.url, {
+        const res = await worker.fetch(req.url, {
           method: req.method,
           headers: req.headers as any,
           body: req.body as any,
-          redirect: "manual",
           duplex: "half",
+          redirect: "manual",
         });
         return res as unknown as Response;
       } catch (error) {

package/src/cloudflare/miniflare/remote-binding-proxy.ts

@@ -1,5 +1,5 @@
 import type { RemoteProxyConnectionString } from "miniflare";
-import { HTTPServer } from "../../util/http-server.ts";
+import { HTTPServer } from "../../util/http.ts";
 import { extractCloudflareResult } from "../api-response.ts";
 import { createCloudflareApi, type CloudflareApi } from "../api.ts";
 import type { WorkerBindingSpec } from "../bindings.ts";
@@ -22,6 +22,12 @@ interface WorkersPreviewSession {
   token: string;
 }
 
+export interface RemoteBindingProxy {
+  server: HTTPServer;
+  bindings: WorkerBindingSpec[];
+  connectionString: RemoteProxyConnectionString;
+}
+
 export async function createRemoteProxyWorker(input: {
   name: string;
   bindings: WorkerBindingSpec[];
@@ -47,62 +53,44 @@ export async function createRemoteProxyWorker(input: {
     }),
     import("../worker-subdomain.ts").then((m) => m.getAccountSubdomain(api)),
   ]);
-  return new RemoteBindingProxy(
-    `https://${input.name}.${subdomain}.workers.dev`,
-    token,
-    input.bindings,
-  );
-}
 
-export class RemoteBindingProxy {
-  server: HTTPServer;
+  const proxyURL = new URL(`https://${input.name}.${subdomain}.workers.dev`);
+  const server = new HTTPServer({
+    fetch: async (req) => {
+      const origin = new URL(req.url);
+      const url = new URL(origin.pathname, proxyURL.toString());
+      url.search = origin.search;
+      url.hash = origin.hash;
 
-  constructor(
-    readonly url: string,
-    readonly token: string,
-    readonly bindings: WorkerBindingSpec[],
-  ) {
-    this.server = new HTTPServer({
-      fetch: this.fetch.bind(this),
-    });
-  }
+      const requestHeaders = new Headers(req.headers);
+      requestHeaders.set("cf-workers-preview-token", token);
+      requestHeaders.set("host", proxyURL.hostname);
+      requestHeaders.delete("cf-connecting-ip");
 
-  get connectionString() {
-    const hostname =
-      this.server.hostname === "::" ? "localhost" : this.server.hostname;
-    return new URL(
-      `http://${hostname}:${this.server.port}`,
-    ) as RemoteProxyConnectionString;
-  }
-
-  async fetch(req: Request) {
-    const origin = new URL(req.url);
-    const url = new URL(origin.pathname, this.url);
-    url.search = origin.search;
-    url.hash = origin.hash;
-
-    const headers = new Headers(req.headers);
-    headers.set("cf-workers-preview-token", this.token);
-    headers.set("host", new URL(this.url).hostname);
-    headers.delete("cf-connecting-ip");
-
-    const res = await fetch(url, {
-      method: req.method,
-      headers,
-      body: req.body,
-      redirect: "manual",
-    });
+      const res = await fetch(url, {
+        method: req.method,
+        headers: requestHeaders,
+        body: req.body,
+        redirect: "manual",
+      });
 
-    // Remove headers that are not supported by miniflare
-    const responseHeaders = new Headers(res.headers);
-    responseHeaders.delete("transfer-encoding");
-    responseHeaders.delete("content-encoding");
+      // Remove headers that are not supported by miniflare
+      const responseHeaders = new Headers(res.headers);
+      responseHeaders.delete("transfer-encoding");
+      responseHeaders.delete("content-encoding");
 
-    return new Response(res.body, {
-      status: res.status,
-      headers: responseHeaders,
-    });
-  }
+      return new Response(res.body, {
+        status: res.status,
+        headers: responseHeaders,
+      });
+    },
+  });
+  await server.listen();
+  return {
+    server,
+    bindings: input.bindings,
+    connectionString: new URL(server.url) as RemoteProxyConnectionString,
+  };
 }
 
 async function createWorkersPreviewToken(

package/src/cloudflare/oauth.ts

@@ -7,7 +7,7 @@ import os from "node:os";
 import path from "node:path";
 import open from "open";
 import xdgAppPaths from "xdg-app-paths";
-import { HTTPServer } from "../util/http-server.ts";
+import { HTTPServer } from "../util/http.ts";
 import { memoize } from "../util/memoize.ts";
 import {
   detached,
@@ -145,7 +145,6 @@ export const wranglerLogin = (
     return Response.redirect(`${ALCHEMY_BASE_URL}/auth/${type}`);
   };
   const server = new HTTPServer({
-    port: 8976,
     fetch: async (request) => {
       const url = new URL(request.url);
       if (url.pathname !== "/oauth/callback") {
@@ -190,6 +189,7 @@ export const wranglerLogin = (
       return renderResponse("success");
     },
   });
+  server.listen(8976);
   const timeout = setTimeout(
     () => {
       err(
@@ -204,7 +204,7 @@ export const wranglerLogin = (
   );
   return ensure(result, () => {
     clearTimeout(timeout);
-    void server.stop();
+    void server.close();
   });
 };
 

package/src/cloudflare/website.ts

@@ -5,12 +5,8 @@ import { Scope } from "../scope.ts";
 import { detectPackageManager } from "../util/detect-package-manager.ts";
 import { Assets } from "./assets.ts";
 import type { Bindings } from "./bindings.ts";
-import {
-  DEFAULT_COMPATIBILITY_DATE,
-  Worker,
-  type AssetsConfig,
-  type WorkerProps,
-} from "./worker.ts";
+import { DEFAULT_COMPATIBILITY_DATE } from "./compatibility-date.gen.ts";
+import { Worker, type AssetsConfig, type WorkerProps } from "./worker.ts";
 import { WranglerJson, type WranglerJsonSpec } from "./wrangler.json.ts";
 
 export interface WebsiteProps<B extends Bindings>

package/src/cloudflare/worker.ts

@@ -4,7 +4,6 @@ import { spawn } from "node:child_process";
 import fs from "node:fs/promises";
 import { isDeepStrictEqual } from "node:util";
 import path from "pathe";
-import { BUILD_DATE } from "../build-date.ts";
 import type { Context } from "../context.ts";
 import type { BundleProps } from "../esbuild/bundle.ts";
 import { InnerResourceScope, Resource, ResourceKind } from "../resource.ts";
@@ -43,6 +42,7 @@ import {
   normalizeWorkerBundle,
 } from "./bundle/index.ts";
 import { wrap } from "./bundle/normalize.ts";
+import { DEFAULT_COMPATIBILITY_DATE } from "./compatibility-date.gen.ts";
 import {
   type CompatibilityPreset,
   unionCompatibilityFlags,
@@ -212,7 +212,7 @@ export interface BaseWorkerProps<
 
   /**
    * The compatibility date for the worker
-   * @default BUILD_DATE - automatically pinned to the package build date
+   * @default DEFAULT_WORKER_COMPATIBILITY_DATE - automatically pinned to the latest Workers release
    */
   compatibilityDate?: string;
 
@@ -1013,8 +1013,6 @@ export function Worker<const B extends Bindings>(
   });
 }
 
-export const DEFAULT_COMPATIBILITY_DATE = BUILD_DATE;
-
 export const _Worker = Resource(
   "cloudflare::Worker",
   {
@@ -1102,6 +1100,7 @@ export const _Worker = Resource(
           bindings: props.bindings,
           bundle,
           port: props.dev?.port,
+          assets: props.assets,
         });
       }
 
@@ -1671,6 +1670,7 @@ async function createMiniflare(props: {
   bindings: Bindings | undefined;
   port: number | undefined;
   bundle: WorkerBundleProvider;
+  assets: AssetsConfig | undefined;
 }) {
   const sharedOptions: Omit<MiniflareWorkerOptions, "bundle"> = {
     name: props.workerName,
@@ -1678,6 +1678,7 @@ async function createMiniflare(props: {
     compatibilityFlags: props.compatibilityFlags,
     bindings: props.bindings,
     port: props.port,
+    assets: props.assets,
   };
 
   const startPromise = new DeferredPromise<string>();
@@ -1837,14 +1838,6 @@ async function createDevCommand(props: {
     }
   }
   const command = props.command.split(" ");
-  console.log({
-    command,
-    args: command.slice(1),
-    cwd: props.cwd,
-    env: {
-      ...props.env,
-    },
-  });
   const proc = spawn(command[0], command.slice(1), {
     cwd: props.cwd,
     env: {

package/src/scope.ts

@@ -125,6 +125,7 @@ export class Scope {
   public readonly dataMutex: AsyncMutex;
 
   private isErrored = false;
+  private isSkipped = false;
   private finalized = false;
   private startedAt = performance.now();
 
@@ -194,6 +195,17 @@ export class Scope {
     this.dataMutex = new AsyncMutex();
   }
 
+  /**
+   * @internal
+   */
+  public clear() {
+    for (const child of this.children.values()) {
+      child.clear();
+    }
+    this.resources.clear();
+    this.children.clear();
+  }
+
   public get root(): Scope {
     let root: Scope = this;
     while (root.parent) {
@@ -239,6 +251,10 @@ export class Scope {
     this.isErrored = true;
   }
 
+  public skip() {
+    this.isSkipped = true;
+  }
+
   public async init() {
     await Promise.all([
       this.state.init?.(),
@@ -378,7 +394,7 @@ export class Scope {
     this.finalized = true;
     // trigger and await all deferred promises
     await Promise.all(this.deferred.map((fn) => fn()));
-    if (!this.isErrored) {
+    if (!this.isErrored && !this.isSkipped) {
       // TODO: need to detect if it is in error
       const resourceIds = await this.state.list();
       const aliveIds = new Set(this.resources.keys());

package/src/state/cloudflare-state-store.ts

@@ -1,8 +1,8 @@
 import { alchemy } from "../alchemy.ts";
-import { BUILD_DATE } from "../build-date.ts";
 import type { CloudflareApiOptions } from "../cloudflare/api.ts";
 import { createCloudflareApi } from "../cloudflare/api.ts";
 import { getInternalWorkerBundle } from "../cloudflare/bundle/internal-worker-bundle.ts";
+import { DEFAULT_COMPATIBILITY_DATE } from "../cloudflare/compatibility-date.gen.ts";
 import { DurableObjectNamespace } from "../cloudflare/durable-object-namespace.ts";
 import { getWorkerSettings } from "../cloudflare/worker-metadata.ts";
 import {
@@ -109,7 +109,7 @@ const provision = memoize(async (options: CloudflareStateStoreOptions) => {
     );
     await putWorker(api, {
       workerName: scriptName,
-      compatibilityDate: BUILD_DATE,
+      compatibilityDate: DEFAULT_COMPATIBILITY_DATE,
       format: "esm",
       scriptBundle: {
         entrypoint: bundle.file.name,

package/src/util/http.ts

@@ -0,0 +1,94 @@
+import http from "node:http";
+import type { AddressInfo } from "node:net";
+import { Readable } from "node:stream";
+
+export class HTTPServer {
+  httpServer: http.Server;
+
+  constructor(options: {
+    fetch: (request: Request) => Promise<Response>;
+  }) {
+    this.httpServer = http.createServer();
+    this.httpServer.on("request", async (req, res) => {
+      const response = await options.fetch(toWebRequest(req));
+      await writeNodeResponse(res, response);
+    });
+  }
+
+  listen(port?: number) {
+    return new Promise<this>((resolve, reject) => {
+      this.httpServer.on("listening", () => {
+        resolve(this);
+      });
+      this.httpServer.on("error", (error) => {
+        reject(error);
+      });
+      this.httpServer.listen(port);
+    });
+  }
+
+  get url() {
+    const address = this.httpServer.address() as AddressInfo | null;
+    if (!address) {
+      throw new Error("Server is not listening");
+    }
+    const hostname = address.address === "::" ? "localhost" : address.address;
+    return `http://${hostname}:${address.port}`;
+  }
+
+  close() {
+    return new Promise((resolve, reject) => {
+      this.httpServer.close((err) => {
+        if (err) {
+          reject(err);
+        } else {
+          resolve(undefined);
+        }
+      });
+    });
+  }
+}
+
+export function toWebRequest(
+  req: http.IncomingMessage,
+  host?: string,
+): Request {
+  const method = req.method ?? "GET";
+  const url = new URL(req.url ?? "/", `http://${host ?? req.headers.host}`);
+  const body =
+    ["GET", "HEAD", "OPTIONS"].includes(method) || !req.readable
+      ? undefined
+      : Readable.toWeb(req);
+  return new Request(url.toString(), {
+    method,
+    headers: req.headers as Record<string, string>,
+    body: body as unknown as BodyInit,
+    // @ts-expect-error - caused by @cloudflare/workers-types
+    duplex: body ? "half" : undefined,
+    redirect: "manual",
+  });
+}
+
+export async function writeNodeResponse(
+  res: http.ServerResponse,
+  response: Response,
+) {
+  res.statusCode = response.status;
+  response.headers.forEach((value, key) => {
+    res.setHeader(key, value);
+  });
+  if (response.body) {
+    await response.body.pipeTo(
+      new WritableStream({
+        write(chunk) {
+          res.write(chunk);
+        },
+        close() {
+          res.end();
+        },
+      }),
+    );
+  } else {
+    res.end();
+  }
+}

package/lib/build-date.d.ts

@@ -1,6 +0,0 @@
-/**
- * The build date used as the default worker compatibility date.
- * This is set to the date when the package was built.
- */
-export declare const BUILD_DATE = "2025-07-16";
-//# sourceMappingURL=build-date.d.ts.map

package/lib/build-date.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"build-date.d.ts","sourceRoot":"","sources":["../src/build-date.ts"],"names":[],"mappings":"AAGA;;;GAGG;AACH,eAAO,MAAM,UAAU,eAAe,CAAC"}

package/lib/build-date.js

@@ -1,8 +0,0 @@
-// This file is auto-generated during build
-// Do not edit manually
-/**
- * The build date used as the default worker compatibility date.
- * This is set to the date when the package was built.
- */
-export const BUILD_DATE = "2025-07-16";
-//# sourceMappingURL=build-date.js.map

package/lib/build-date.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"build-date.js","sourceRoot":"","sources":["../src/build-date.ts"],"names":[],"mappings":"AAAA,2CAA2C;AAC3C,uBAAuB;AAEvB;;;GAGG;AACH,MAAM,CAAC,MAAM,UAAU,GAAG,YAAY,CAAC"}

package/lib/util/http-server.d.ts

@@ -1,14 +0,0 @@
-import http from "node:http";
-export declare class HTTPServer {
-    server: http.Server;
-    ready: Promise<void>;
-    constructor(options: {
-        port?: number;
-        fetch: (request: Request) => Promise<Response>;
-    });
-    get port(): number;
-    get hostname(): string;
-    get url(): string;
-    stop(): Promise<unknown>;
-}
-//# sourceMappingURL=http-server.d.ts.map

package/lib/util/http-server.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"http-server.d.ts","sourceRoot":"","sources":["../../src/util/http-server.ts"],"names":[],"mappings":"AAAA,OAAO,IAAI,MAAM,WAAW,CAAC;AAK7B,qBAAa,UAAU;IACrB,MAAM,EAAE,IAAI,CAAC,MAAM,CAAC;IACpB,KAAK,EAAE,OAAO,CAAC,IAAI,CAAC,CAAC;gBAET,OAAO,EAAE;QACnB,IAAI,CAAC,EAAE,MAAM,CAAC;QACd,KAAK,EAAE,CAAC,OAAO,EAAE,OAAO,KAAK,OAAO,CAAC,QAAQ,CAAC,CAAC;KAChD;IAWD,IAAI,IAAI,WAEP;IAED,IAAI,QAAQ,WAMX;IAED,IAAI,GAAG,WAEN;IAED,IAAI;CAWL"}