alchemy 0.55.3 → 0.57.0

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

@@ -32,7 +32,7 @@ export interface RemoteBindingProxy {
 export async function createRemoteProxyWorker(input: {
   name: string;
   bindings: WorkerBindingSpec[];
-}) {
+}): Promise<RemoteBindingProxy> {
   const api = await createCloudflareApi();
   const script = await getInternalWorkerBundle("remote-binding-proxy");
   const [token, subdomain] = await Promise.all([
@@ -42,9 +42,7 @@ export async function createRemoteProxyWorker(input: {
         main_module: script.bundle.entrypoint,
         compatibility_date: "2025-06-16",
         bindings: input.bindings,
-        observability: {
-          enabled: false,
-        },
+        observability: { enabled: false },
       },
       bundle: script.bundle,
       session: {
@@ -55,27 +53,24 @@ export async function createRemoteProxyWorker(input: {
     import("../worker-subdomain.ts").then((m) => m.getAccountSubdomain(api)),
   ]);
 
-  const proxyURL = new URL(`https://${input.name}.${subdomain}.workers.dev`);
+  const proxyURL = `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;
+      const url = new URL(req.url);
+      const targetUrl = new URL(url.pathname + url.search, proxyURL);
 
-      const requestHeaders = new Headers(req.headers);
-      requestHeaders.set("cf-workers-preview-token", token);
-      requestHeaders.set("host", proxyURL.hostname);
-      requestHeaders.delete("cf-connecting-ip");
+      const headers = new Headers(req.headers);
+      headers.set("cf-workers-preview-token", token);
+      headers.set("host", new URL(proxyURL).hostname);
+      headers.delete("cf-connecting-ip");
 
-      const res = await fetch(url, {
+      const res = await fetch(targetUrl, {
         method: req.method,
-        headers: requestHeaders,
+        headers,
         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");
@@ -86,6 +81,7 @@ export async function createRemoteProxyWorker(input: {
       });
     },
   });
+
   await server.listen();
   return {
     server,
@@ -126,13 +122,12 @@ async function createWorkersPreviewToken(
 }
 
 async function prewarm(url: string, previewToken: string) {
-  const res = await fetch(url, {
-    headers: {
-      "cf-workers-preview-token": previewToken,
-    },
-  });
-  if (!res.ok) {
-    console.error(`Failed to prewarm worker: ${res.status} ${res.statusText}`);
+  try {
+    await fetch(url, {
+      headers: { "cf-workers-preview-token": previewToken },
+    });
+  } catch {
+    // Ignore prewarm errors
   }
 }
 

package/src/cloudflare/{nuxt.ts → nuxt/nuxt.ts}

@@ -1,8 +1,9 @@
 import path from "node:path";
-import type { Assets } from "./assets.ts";
-import type { Bindings } from "./bindings.ts";
-import { Website, type WebsiteProps } from "./website.ts";
-import type { Worker } from "./worker.ts";
+import { getPackageManagerRunner } from "../../util/detect-package-manager.ts";
+import type { Assets } from "../assets.ts";
+import type { Bindings } from "../bindings.ts";
+import { Website, type WebsiteProps } from "../website.ts";
+import type { Worker } from "../worker.ts";
 
 /**
  * Properties for creating a Nuxt resource.
@@ -50,22 +51,16 @@ export async function Nuxt<B extends Bindings>(
   id: string,
   props?: Partial<NuxtProps<B>>,
 ): Promise<Nuxt<B>> {
-  // Call the underlying Website resource with Nuxt defaults
-  return Website(id, {
+  const runner = await getPackageManagerRunner();
+  return await Website(id, {
     ...props,
     noBundle: props?.noBundle ?? true,
-    // Default build command, can be overridden by props.command
-    command: props?.command ?? "nuxt build",
+    build: props?.build ?? `${runner} nuxt build`,
+    dev: props?.dev ?? `${runner} nuxt dev`,
+    compatibility: "node",
     // Default entry point for cloudflare-module preset
-    main: props?.main ?? "./.output/server/index.mjs",
+    entrypoint: props?.entrypoint ?? "./.output/server/index.mjs",
     // Default static assets directory for cloudflare-module preset
     assets: props?.assets ?? path.join(".output", "public"),
-    // Ensure nodejs_compat flag is included for Nuxt compatibility
-    compatibilityFlags: ["nodejs_compat", ...(props?.compatibilityFlags ?? [])],
-    // Enable wrangler by default, common for Nuxt/Cloudflare deployments
-    wrangler: props?.wrangler ?? true,
-    dev: props?.dev ?? {
-      command: "nuxt dev",
-    },
   });
 }

package/src/cloudflare/nuxt/plugin.ts

@@ -0,0 +1,18 @@
+import type { CloudflareOptions } from "nitropack/presets/cloudflare/types";
+import { validateConfigPath, validatePersistPath } from "../miniflare/paths.ts";
+
+const alchemy = (
+  options: Partial<CloudflareOptions> = {},
+): CloudflareOptions => {
+  return {
+    nodeCompat: true,
+    dev: {
+      configPath: validateConfigPath(options.dev?.configPath),
+      persistDir: validatePersistPath(options.dev?.persistDir),
+      ...options.dev,
+    },
+    ...options,
+  };
+};
+
+export default alchemy;

package/src/cloudflare/oauth.ts

@@ -6,7 +6,7 @@ import fs from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
 import open from "open";
-import xdgAppPaths from "xdg-app-paths";
+import envPaths from "env-paths";
 import { HTTPServer } from "../util/http.ts";
 import { memoize } from "../util/memoize.ts";
 import {
@@ -70,7 +70,7 @@ export const getRefreshedWranglerConfig = singleFlight(() =>
 );
 
 const getWranglerConfigPath = memoize(async () => {
-  const xdgConfigDir = xdgAppPaths(".wrangler").config();
+  const xdgConfigDir = envPaths(".wrangler", { suffix: "" }).config;
   const legacyConfigDir = path.join(os.homedir(), ".wrangler");
   const configDir = (await fs
     .stat(legacyConfigDir)

package/src/cloudflare/orange.ts

@@ -1,9 +1,9 @@
 import type { Assets } from "./assets.js";
 import type { Bindings } from "./bindings.js";
-import { Website, type WebsiteProps } from "./website.js";
-import type { Worker } from "./worker.js";
+import { Vite, type ViteProps } from "./vite/vite.ts";
+import type { Worker } from "./worker.ts";
 
-export interface OrangeProps<B extends Bindings> extends WebsiteProps<B> {}
+export interface OrangeProps<B extends Bindings> extends ViteProps<B> {}
 
 // don't allow the ASSETS to be overriden
 export type Orange<B extends Bindings> = B extends { ASSETS: any }
@@ -36,29 +36,19 @@ export type Orange<B extends Bindings> = B extends { ASSETS: any }
  */
 export async function Orange<B extends Bindings>(
   id: string,
-  props?: Partial<OrangeProps<B>>,
+  props: Partial<OrangeProps<B>> = {},
 ): Promise<Orange<B>> {
-  return Website(id, {
+  return await Vite(id, {
     ...props,
-    command: props?.command ?? "vite build",
-    dev: props?.dev ?? {
-      command: "vite dev",
-    },
-    // The entrypoint and the Wrangler main must differ for the Cloudflare vite plugin
-    // to bundle the application correctly, and alchemy must run our bundler on the Vite
-    // output since we don't resolve vite imports.
-    wrangler: props?.wrangler ?? {
+    noBundle: props.noBundle ?? true,
+    entrypoint: props.entrypoint ?? "dist/ssr/entry.server.js",
+    assets: props.assets ?? "dist/client",
+    compatibilityFlags: ["nodejs_compat", ...(props?.compatibilityFlags ?? [])],
+    wrangler: {
+      path: "wrangler.jsonc",
       main: "app/entry.server.ts",
+      secrets: false,
+      ...props.wrangler,
     },
-    // Since we've already bundled the application with the build command, we can just
-    // upload the modules in the `dist/srr` directory. With `noBundle: true`, any files
-    // that match `**/*.js`, `**/*.mjs`, and `**/*.wasm` under the entrypoint's directory
-    // (which is `dist/ssr`) will be uploaded to the worker so we don't need any explicit
-    // module rules.
-    noBundle: true,
-    // `main` is used as the entrypoint in the Worker resource.
-    main: props?.main ?? "dist/ssr/entry.server.js",
-    assets: props?.assets ?? "dist/client",
-    compatibilityFlags: ["nodejs_compat", ...(props?.compatibilityFlags ?? [])],
   });
 }

package/src/cloudflare/react-router/plugin.ts

@@ -0,0 +1,13 @@
+import type { PluginConfig } from "@cloudflare/vite-plugin";
+import alchemyVite from "../vite/plugin.ts";
+
+const alchemy = (config?: PluginConfig) => {
+  return alchemyVite({
+    ...config,
+    viteEnvironment: {
+      name: "ssr",
+    },
+  });
+};
+
+export default alchemy;

package/src/cloudflare/react-router/react-router.ts

@@ -0,0 +1,41 @@
+import { getPackageManagerRunner } from "../../util/detect-package-manager.ts";
+import type { Assets } from "../assets.ts";
+import type { Bindings } from "../bindings.ts";
+import { Vite, type ViteProps } from "../vite/vite.ts";
+import type { Worker } from "../worker.ts";
+
+export interface ReactRouterProps<B extends Bindings> extends ViteProps<B> {
+  /**
+   * @default workers/app.ts
+   */
+  main?: string;
+}
+
+// don't allow the ASSETS to be overriden
+export type ReactRouter<B extends Bindings> = B extends { ASSETS: any }
+  ? never
+  : Worker<B & { ASSETS: Assets }>;
+
+export async function ReactRouter<B extends Bindings>(
+  id: string,
+  props: ReactRouterProps<B> = {},
+): Promise<ReactRouter<B>> {
+  const runner = await getPackageManagerRunner();
+  return await Vite(id, {
+    ...props,
+    build:
+      props.build ??
+      `${runner} react-router typegen && ${runner} react-router build`,
+    dev:
+      props.dev ??
+      `${runner} react-router typegen && ${runner} react-router dev`,
+    compatibility: "node",
+    entrypoint: props.entrypoint ?? "build/server/index.js",
+    noBundle: props.noBundle ?? true,
+    assets: props.assets ?? "build/client",
+    wrangler: {
+      main: props.wrangler?.main ?? props.main ?? "workers/app.ts",
+      transform: props.wrangler?.transform,
+    },
+  });
+}

package/src/cloudflare/redwood/plugin.ts

@@ -0,0 +1,20 @@
+import { redwood, type RedwoodPluginOptions } from "rwsdk/vite";
+import { DEFAULT_CONFIG_PATH } from "../miniflare/paths.ts";
+import alchemyVite from "../vite/plugin.ts";
+
+const alchemyRedwood = (options?: RedwoodPluginOptions) => {
+  const configPath = options?.configPath ?? DEFAULT_CONFIG_PATH;
+  return [
+    redwood({
+      ...options,
+      configPath,
+      includeCloudflarePlugin: false,
+    }),
+    alchemyVite({
+      configPath,
+      viteEnvironment: { name: "worker" },
+    }),
+  ];
+};
+
+export default alchemyRedwood;

package/src/cloudflare/{redwood.ts → redwood/redwood.ts}

@@ -1,10 +1,10 @@
 import path from "node:path";
-import type { Assets } from "./assets.ts";
-import type { Bindings } from "./bindings.ts";
-import { Website, type WebsiteProps } from "./website.ts";
-import type { Worker } from "./worker.ts";
+import type { Assets } from "../assets.ts";
+import type { Bindings } from "../bindings.ts";
+import { Vite, type ViteProps } from "../vite/vite.ts";
+import type { Worker } from "../worker.ts";
 
-export interface RedwoodProps<B extends Bindings> extends WebsiteProps<B> {}
+export interface RedwoodProps<B extends Bindings> extends ViteProps<B> {}
 
 // don't allow the ASSETS to be overridden
 export type Redwood<B extends Bindings> = B extends { ASSETS: any }
@@ -41,24 +41,21 @@ export async function Redwood<B extends Bindings>(
   id: string,
   props?: Partial<RedwoodProps<B>>,
 ): Promise<Redwood<B>> {
-  return Website(id, {
+  return await Vite(id, {
     ...props,
-    command:
-      props?.command ??
-      "rm -rf ./node_modules/.vite && RWSDK_DEPLOY=1 vite build",
-    dev: props?.dev ?? {
-      command: "vite dev",
+    build: props?.build ?? {
+      command: "rm -rf ./node_modules/.vite && vite build",
+      env: {
+        RWSDK_DEPLOY: "1",
+      },
     },
     noBundle: props?.noBundle ?? true,
-    wrangler:
-      props?.wrangler === false
-        ? false
-        : {
-            main: props?.main ?? path.join("src", "worker.tsx"),
-          },
-    main: props?.main ?? path.join("dist", "worker", "worker.js"),
-    assets: props?.assets ?? path.join("dist", "client"),
+    entrypoint: props?.entrypoint ?? path.join("dist", "worker", "worker.js"),
     compatibilityFlags: ["nodejs_compat", ...(props?.compatibilityFlags ?? [])],
     compatibilityDate: props?.compatibilityDate ?? "2025-04-02",
+    wrangler: {
+      main: props?.wrangler?.main ?? "src/worker.tsx",
+      transform: props?.wrangler?.transform,
+    },
   });
 }

package/src/cloudflare/sveltekit/plugin.ts

@@ -0,0 +1,12 @@
+import adapter, { type AdapterOptions } from "@sveltejs/adapter-cloudflare";
+import { getPlatformProxyOptions } from "../cloudflare-env-proxy.ts";
+
+const alchemy = (options?: AdapterOptions) => {
+  const platformProxy = getPlatformProxyOptions(options?.platformProxy);
+  return adapter({
+    platformProxy,
+    ...options,
+  });
+};
+
+export default alchemy;

package/src/cloudflare/{sveltekit.ts → sveltekit/sveltekit.ts}

@@ -1,10 +1,10 @@
 import { join } from "node:path";
-import type { Assets } from "./assets.ts";
-import type { Bindings } from "./bindings.ts";
-import { Website, type WebsiteProps } from "./website.ts";
-import type { Worker } from "./worker.ts";
+import type { Assets } from "../assets.ts";
+import type { Bindings } from "../bindings.ts";
+import { Vite, type ViteProps } from "../vite/vite.ts";
+import type { Worker } from "../worker.ts";
 
-export interface SvelteKitProps<B extends Bindings> extends WebsiteProps<B> {}
+export interface SvelteKitProps<B extends Bindings> extends ViteProps<B> {}
 
 // don't allow the ASSETS to be overriden
 export type SvelteKit<B extends Bindings> = B extends { ASSETS: any }
@@ -61,12 +61,13 @@ export async function SvelteKit<B extends Bindings>(
     }
   }
 
-  return Website(id, {
+  return await Vite(id, {
     ...props,
-    command: props?.command ?? "bun run build",
-    main: props?.main ?? join(".svelte-kit", "cloudflare", "_worker.js"),
+    entrypoint:
+      props?.entrypoint ?? join(".svelte-kit", "cloudflare", "_worker.js"),
     assets: props?.assets ?? join(".svelte-kit", "cloudflare"),
     compatibilityFlags: ["nodejs_compat", ...(props?.compatibilityFlags ?? [])],
     compatibilityDate: props?.compatibilityDate,
+    wrangler: { secrets: true },
   });
 }

package/src/cloudflare/tanstack-start/plugin.ts

@@ -0,0 +1,30 @@
+import type { GetPlatformProxyOptions } from "wrangler";
+import { dedent } from "../../util/dedent.ts";
+
+/**
+ * TanStackStart server functions and middleware run in Node.js intead of Miniflare when using `vite dev`.
+ *
+ * This plugin polyfills the cloudflare:workers module & includes `process.env` during the dev server phase.
+ *
+ * @see https://developers.cloudflare.com/workers/framework-guides/web-apps/tanstack/#using-cloudflare-bindings
+ */
+export default function alchemy(options: GetPlatformProxyOptions = {}) {
+  return {
+    name: "cloudflare-workers-dev-shim",
+    apply: "serve", // dev‑only
+    enforce: "pre",
+    resolveId(id: string) {
+      if (id === "cloudflare:workers") return id; // tell Vite we handled it
+    },
+    load(id: string) {
+      if (id === "cloudflare:workers") {
+        return dedent`
+          import { getCloudflareEnvProxy } from "alchemy/cloudflare";
+          export const env = await getCloudflareEnvProxy(${JSON.stringify(
+            options,
+          )});
+        `;
+      }
+    },
+  } as const;
+}

package/src/cloudflare/tanstack-start/tanstack-start.ts

@@ -0,0 +1,24 @@
+import type { Assets } from "../assets.ts";
+import type { Bindings } from "../bindings.ts";
+import { Vite, type ViteProps } from "../vite/vite.ts";
+import type { Worker } from "../worker.ts";
+
+export interface TanStackStartProps<B extends Bindings> extends ViteProps<B> {}
+
+// don't allow the ASSETS to be overriden
+export type TanStackStart<B extends Bindings> = B extends { ASSETS: any }
+  ? never
+  : Worker<B & { ASSETS: Assets }>;
+
+export async function TanStackStart<B extends Bindings>(
+  id: string,
+  props?: Partial<TanStackStartProps<B>>,
+): Promise<TanStackStart<B>> {
+  return await Vite(id, {
+    ...props,
+    noBundle: true,
+    entrypoint: props?.entrypoint ?? ".output/server/index.mjs",
+    compatibilityFlags: ["nodejs_compat", ...(props?.compatibilityFlags ?? [])],
+    assets: props?.assets ?? ".output/public",
+  });
+}

package/src/cloudflare/vite/plugin.ts

@@ -0,0 +1,30 @@
+import { cloudflare, type PluginConfig } from "@cloudflare/vite-plugin";
+import path from "node:path";
+import {
+  DEFAULT_PERSIST_PATH,
+  validateConfigPath,
+  validatePersistPath,
+} from "../miniflare/paths.ts";
+
+const alchemy = (config?: PluginConfig) => {
+  const persistState = config?.persistState ?? {
+    path: validatePersistPath(
+      typeof config?.persistState === "object"
+        ? config.persistState.path
+        : DEFAULT_PERSIST_PATH,
+    ),
+  };
+  if (typeof persistState === "object" && persistState.path.endsWith("v3")) {
+    persistState.path = path.dirname(persistState.path);
+  }
+  return cloudflare({
+    ...config,
+    configPath: validateConfigPath(config?.configPath),
+    persistState,
+    experimental: config?.experimental ?? {
+      remoteBindings: true,
+    },
+  });
+};
+
+export default alchemy;

package/src/cloudflare/vite/vite.ts

@@ -0,0 +1,34 @@
+import { getPackageManagerRunner } from "../../util/detect-package-manager.ts";
+import type { Assets } from "../assets.ts";
+import type { Bindings } from "../bindings.ts";
+import { Website, type WebsiteProps } from "../website.ts";
+import type { Worker } from "../worker.ts";
+
+export interface ViteProps<B extends Bindings>
+  extends Omit<WebsiteProps<B>, "spa"> {}
+
+export type Vite<B extends Bindings> = B extends { ASSETS: any }
+  ? never
+  : Worker<B & { ASSETS: Assets }>;
+
+export async function Vite<B extends Bindings>(
+  id: string,
+  props: ViteProps<B>,
+): Promise<Vite<B>> {
+  const runner = await getPackageManagerRunner();
+  return await Website(id, {
+    ...props,
+    spa: true,
+    assets:
+      typeof props.assets === "string"
+        ? { directory: props.assets }
+        : {
+            ...(props.assets ?? {}),
+            directory:
+              props.assets?.directory ??
+              (props.entrypoint || props.script ? "dist/client" : "dist"),
+          },
+    build: props.build ?? `${runner} vite build`,
+    dev: props.dev ?? `${runner} vite dev`,
+  });
+}