alchemy 0.60.2 → 0.62.0

package/src/cloudflare/bucket.ts

@@ -5,8 +5,8 @@ import { Scope } from "../scope.ts";
 import { withExponentialBackoff } from "../util/retry.ts";
 import { CloudflareApiError } from "./api-error.ts";
 import {
-  extractCloudflareError,
   extractCloudflareResult,
+  type CloudflareApiErrorPayload,
 } from "./api-response.ts";
 import {
   createCloudflareApi,
@@ -478,36 +478,40 @@ async function emptyBucket(
   bucketName: string,
   props: BucketProps,
 ) {
-  let batch: Promise<unknown>[] = [];
-  for await (const key of listObjects(api, bucketName, props)) {
-    batch.push(
-      extractCloudflareResult(
-        `delete R2 object "${key}"`,
+  let cursor: string | undefined;
+  while (true) {
+    const result = await listObjects(api, bucketName, props, cursor);
+    if (result.keys.length) {
+      // Another undocumented API! But it lets us delete multiple objects at once instead of one by one.
+      await extractCloudflareResult(
+        `delete ${result.keys.length} objects from bucket "${bucketName}"`,
         api.delete(
-          `/accounts/${api.accountId}/r2/buckets/${bucketName}/objects/${key}`,
-          { headers: withJurisdiction(props) },
+          `/accounts/${api.accountId}/r2/buckets/${bucketName}/objects`,
+          {
+            headers: withJurisdiction(props),
+            method: "DELETE",
+            body: JSON.stringify(result.keys),
+          },
         ),
-      ),
-    );
-    if (batch.length >= 10) {
-      // this is an arbitary batch size, open to feedback
-      await Promise.all(batch);
-      batch = [];
+      );
+      if (result.cursor) {
+        cursor = result.cursor;
+        continue;
+      }
     }
+    break;
   }
-  await Promise.all(batch);
 }
 
 /**
- * Returns an async iterable of all object keys in a bucket,
- * handling pagination automatically.
+ * Lists objects in a bucket.
  */
-export async function* listObjects(
+export async function listObjects(
   api: CloudflareApi,
   bucketName: string,
   props: { jurisdiction?: string },
   cursor?: string,
-): AsyncGenerator<string> {
+) {
   const params = new URLSearchParams({
     per_page: "1000",
   });
@@ -518,11 +522,6 @@ export async function* listObjects(
     `/accounts/${api.accountId}/r2/buckets/${bucketName}/objects?${params.toString()}`,
     { headers: withJurisdiction(props) },
   );
-  if (!response.ok) {
-    throw new Error(
-      `Failed to list objects in bucket "${bucketName}": ${await extractCloudflareError(response)}`,
-    );
-  }
   const json: {
     result: { key: string }[];
     result_info?: {
@@ -530,13 +529,24 @@ export async function* listObjects(
       is_truncated: boolean;
       per_page: number;
     };
+    success: boolean;
+    errors: CloudflareApiErrorPayload[];
   } = await response.json();
-  for (const object of json.result) {
-    yield object.key;
-  }
-  if (json.result_info?.is_truncated && json.result_info.cursor) {
-    yield* listObjects(api, bucketName, props, json.result_info.cursor);
+  if (!json.success) {
+    // 10006 indicates that the bucket does not exist, so there are no objects to list
+    if (json.errors.some((e) => e.code === 10006)) {
+      return { keys: [], cursor: undefined };
+    }
+    throw new CloudflareApiError(
+      `Failed to list objects in bucket "${bucketName}": ${json.errors.map((e) => `- [${e.code}] ${e.message}${e.documentation_url ? ` (${e.documentation_url})` : ""}`).join("\n")}`,
+      response,
+      json.errors,
+    );
   }
+  return {
+    keys: json.result.map((object) => object.key),
+    cursor: json.result_info?.cursor,
+  };
 }
 
 /**

package/src/cloudflare/bundle/plugin-compat-warning.ts

@@ -1,7 +1,7 @@
 import type { Plugin, PluginBuild } from "esbuild";
-import kleur from "kleur";
 import module from "node:module";
 import path from "node:path";
+import pc from "picocolors";
 import { logger } from "../../util/logger.ts";
 
 const NODE_REGEX = new RegExp(
@@ -54,13 +54,13 @@ export function esbuildPluginCompatWarning(mode: "als" | null): Plugin {
         if (packages.size > 0) {
           const formattedImports = Array.from(packages)
             .sort()
-            .map((imp) => kleur.yellow(imp))
+            .map((imp) => pc.yellow(imp))
             .join(", ");
 
           logger.warn(
             [
-              `Detected Node.js imports (${formattedImports}) but ${kleur.red("nodejs_compat")} compatibility flag is not set. `,
-              `Add ${kleur.blue("nodejs_compat")} to your compatibility flags and ensure compatibilityDate >= 2024-09-23. Imported from:`,
+              `Detected Node.js imports (${formattedImports}) but ${pc.red("nodejs_compat")} compatibility flag is not set. `,
+              `Add ${pc.blue("nodejs_compat")} to your compatibility flags and ensure compatibilityDate >= 2024-09-23. Imported from:`,
               formatImporters(
                 nodeImporters,
                 build.initialOptions.absWorkingDir ?? process.cwd(),
@@ -72,8 +72,8 @@ export function esbuildPluginCompatWarning(mode: "als" | null): Plugin {
         if (alsImporters.size > 0 && !mode) {
           logger.warn(
             [
-              `Detected import of ${kleur.yellow("node:async_hooks")} but ${kleur.red("nodejs_als")} compatibility flag is not set. `,
-              `Add ${kleur.blue("nodejs_als")} or ${kleur.blue("nodejs_compat")} to your compatibility flags. Imported from:`,
+              `Detected import of ${pc.yellow("node:async_hooks")} but ${pc.red("nodejs_als")} compatibility flag is not set. `,
+              `Add ${pc.blue("nodejs_als")} or ${pc.blue("nodejs_compat")} to your compatibility flags. Imported from:`,
               formatImporters(
                 alsImporters,
                 build.initialOptions.absWorkingDir ?? process.cwd(),
@@ -89,6 +89,6 @@ export function esbuildPluginCompatWarning(mode: "als" | null): Plugin {
 function formatImporters(importers: Set<string>, cwd: string) {
   return Array.from(importers)
     .sort()
-    .map((imp) => `- ${kleur.yellow(path.relative(cwd, imp))}`)
+    .map((imp) => `- ${pc.yellow(path.relative(cwd, imp))}`)
     .join("\n");
 }

package/src/cloudflare/cloudflare-env-proxy.ts

@@ -41,10 +41,10 @@ export const getPlatformProxyOptions = (
     ...input,
     configPath: validateConfigPath(input.configPath ?? DEFAULT_CONFIG_PATH),
     persist,
-    experimental: input.experimental ?? {
+    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-08-10";
+export const DEFAULT_COMPATIBILITY_DATE = "2025-08-13";

package/src/cloudflare/d1-migrations.ts

@@ -1,3 +1,4 @@
+import { glob } from "glob";
 import * as fs from "node:fs/promises";
 import * as path from "node:path";
 import { logger } from "../util/logger.ts";
@@ -159,11 +160,9 @@ async function migrateLegacySchema(
 export async function listMigrationsFiles(
   migrationsDir: string,
 ): Promise<Array<{ id: string; sql: string }>> {
-  const entries = await Array.fromAsync(
-    fs.glob("**/*.sql", {
-      cwd: migrationsDir,
-    }),
-  );
+  const entries = await glob("**/*.sql", {
+    cwd: migrationsDir,
+  });
 
   const sqlFiles = entries.sort((a: string, b: string) => {
     const aNum = getPrefix(a);

package/src/cloudflare/index.ts

@@ -39,13 +39,14 @@ export * from "./permission-groups.ts";
 export * from "./pipeline.ts";
 export * from "./queue-consumer.ts";
 export * from "./queue.ts";
+export * from "./quick-tunnel.ts";
 export * from "./rate-limit.ts";
 export * from "./react-router/react-router.ts";
 export * from "./redirect-rule.ts";
 export * from "./redwood/redwood.ts";
 export * from "./route.ts";
-export * from "./ruleset.ts";
 export * from "./rule.ts";
+export * from "./ruleset.ts";
 export * from "./secret-key.ts";
 export * from "./secret.ts";
 export * from "./secrets-store.ts";

package/src/cloudflare/kv-namespace.ts

@@ -100,41 +100,40 @@ export function isKVNamespace(resource: Resource): resource is KVNamespace {
 /**
  * Output returned after KV Namespace creation/update
  */
-export interface KVNamespace
-  extends Resource<"cloudflare::KVNamespace">,
-    Omit<KVNamespaceProps, "delete" | "dev"> {
-  type: "kv_namespace";
-  /**
-   * The ID of the namespace
-   */
-  namespaceId: string;
-
-  /**
-   * Time at which the namespace was created
-   */
-  createdAt: number;
+export type KVNamespace = Resource<"cloudflare::KVNamespace"> &
+  Omit<KVNamespaceProps, "delete" | "dev"> & {
+    type: "kv_namespace";
+    /**
+     * The ID of the namespace
+     */
+    namespaceId: string;
 
-  /**
-   * Time at which the namespace was last modified
-   */
-  modifiedAt: number;
+    /**
+     * Time at which the namespace was created
+     */
+    createdAt: number;
 
-  /**
-   * Development mode properties
-   * @internal
-   */
-  dev: {
     /**
-     * The ID of the KV namespace in development mode
+     * Time at which the namespace was last modified
      */
-    id: string;
+    modifiedAt: number;
 
     /**
-     * Whether the KV namespace is running remotely
+     * Development mode properties
+     * @internal
      */
-    remote: boolean;
+    dev: {
+      /**
+       * The ID of the KV namespace in development mode
+       */
+      id: string;
+
+      /**
+       * Whether the KV namespace is running remotely
+       */
+      remote: boolean;
+    };
   };
-}
 
 /**
  * A Cloudflare KV Namespace is a key-value store that can be used to store data for your application.

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

@@ -69,9 +69,15 @@ export const buildWorkerOptions = async (
     name: input.name,
     compatibilityDate: input.compatibilityDate,
     compatibilityFlags: input.compatibilityFlags,
-    // TODO: Setting `proxy: true` here causes the following error when connecting via a websocket:
-    // workerd/io/worker.c++:2164: info: uncaught exception; source = Uncaught (in promise); stack = TypeError: Invalid URL string.
-    unsafeDirectSockets: [{ proxy: false }],
+    unsafeDirectSockets: [
+      // This matches the Wrangler configuration by exposing the default handler (e.g. `export default { fetch }`).
+      // However, unlike Wrangler, we set `proxy: false` to avoid the following error when connecting via a websocket:
+      // workerd/io/worker.c++:2164: info: uncaught exception; source = Uncaught (in promise); stack = TypeError: Invalid URL string.
+      {
+        entrypoint: "default",
+        proxy: false,
+      },
+    ],
     containerEngine: {
       localDocker: {
         socketPath:
@@ -164,6 +170,13 @@ export const buildWorkerOptions = async (
           scriptName: binding.scriptName,
           useSQLite: binding.sqlite,
         };
+        // This matches Wrangler configuration for exposing durable objects as an entrypoint.
+        // See https://github.com/cloudflare/workers-sdk/blob/ae0c806087c203da6a3d7da450e8fabe0d81c987/packages/wrangler/src/dev/miniflare/index.ts#L1266
+        options.unsafeDirectSockets!.push({
+          entrypoint: binding.className,
+          serviceName: binding.scriptName,
+          proxy: true,
+        });
         break;
       }
       case "hyperdrive": {

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

@@ -82,6 +82,10 @@ export class MiniflareController {
         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,
       };
       for (const worker of this.options.values()) {
         options.workers.push(worker);

package/src/cloudflare/oauth.ts

@@ -1,4 +1,4 @@
-import kleur from "kleur";
+import envPaths from "env-paths";
 import { err, ok, okAsync, ResultAsync } from "neverthrow";
 import assert from "node:assert";
 import crypto from "node:crypto";
@@ -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 envPaths from "env-paths";
+import pc from "picocolors";
 import { HTTPServer } from "../util/http.ts";
 import { memoize } from "../util/memoize.ts";
 import {
@@ -133,7 +133,7 @@ export const wranglerLogin = (
     [
       "Opening browser to authorize with Cloudflare...",
       "",
-      kleur.gray(
+      pc.gray(
         "If you are not automatically redirected, please open the following URL in your browser:",
       ),
       challenge.url,

package/src/cloudflare/quick-tunnel.ts

@@ -0,0 +1,30 @@
+import type { Scope } from "../scope.ts";
+
+/**
+ * Starts a Cloudflare Quick Tunnel to a local server.
+ *
+ * @returns the Local URL and the publicly accessible URL of the Quick Tunnel
+ */
+export const quickTunnel = async (
+  scope: Scope,
+  localUrl = "http://localhost:8080",
+) => ({
+  /**
+   * The URL of the local server.
+   */
+  localUrl,
+  /**
+   * The URL of the publicly accessible Quick Tunnel.
+   */
+  tunnelUrl: await scope.spawn("tunnel", {
+    cmd: `cloudflared tunnel --url ${localUrl}`,
+    // used to check if a PID is a cloudflared process when the parent exits, for resumability
+    processName: "cloudflared",
+    extract: (line) => {
+      const match = line.match(/https:\/\/([^\s]+)\.trycloudflare\.com/);
+      if (match) {
+        return `https://${match[1]}.trycloudflare.com`;
+      }
+    },
+  }),
+});

package/src/cloudflare/sveltekit/plugin.ts

@@ -1,12 +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);
+export default (options?: AdapterOptions) => {
+  const { platformProxy: proxyOptions, ...config } = options ?? {};
+  const platformProxy = getPlatformProxyOptions(proxyOptions);
   return adapter({
     platformProxy,
-    ...options,
+    config: platformProxy.configPath,
+    ...config,
   });
 };
-
-export default alchemy;

package/src/cloudflare/website.ts

@@ -1,15 +1,11 @@
 import assert from "node:assert";
-import { spawn } from "node:child_process";
-import { once } from "node:events";
 import fs from "node:fs/promises";
 import path from "node:path";
 import { alchemy } from "../alchemy.ts";
 import { Exec } from "../os/index.ts";
 import { Scope } from "../scope.ts";
-import { isSecret, type Secret } from "../secret.ts";
+import { isSecret } from "../secret.ts";
 import { dedent } from "../util/dedent.ts";
-import { DeferredPromise } from "../util/deferred-promise.ts";
-import { exists } from "../util/exists.ts";
 import { logger } from "../util/logger.ts";
 import { Assets } from "./assets.ts";
 import type { Bindings } from "./bindings.ts";
@@ -304,14 +300,38 @@ export async function Website<B extends Bindings>(
 
     let url: string | undefined;
     if (dev && scope.local) {
-      url = await runDevCommand(scope, {
-        id,
-        command: typeof dev === "string" ? dev : dev.command,
+      url = await scope.spawn(name, {
+        cmd: typeof dev === "string" ? dev : dev.command,
+        cwd: paths.cwd,
+        extract: (line) => {
+          const URL_REGEX =
+            /http:\/\/(localhost|0\.0\.0\.0|127\.0\.0\.1|\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}):\d+\/?/;
+          const match = line
+            .replace(/\x1B\[[0-9;]*[a-zA-Z]/g, "")
+            .match(URL_REGEX);
+          if (match) {
+            return match[0];
+          }
+        },
         env: {
-          ...env,
+          ...Object.fromEntries(
+            Object.entries(env ?? {}).flatMap(([key, value]) => {
+              if (isSecret(value)) {
+                return [[key, value.unencrypted]];
+              }
+              if (typeof value === "string") {
+                return [[key, value]];
+              }
+              return [];
+            }),
+          ),
           ...(typeof dev === "object" ? dev.env : {}),
+          FORCE_COLOR: "1",
+          ...process.env,
+          // NOTE: we must set this to ensure the user does not accidentally set `NODE_ENV=production`
+          // which breaks `vite dev` (it won't, for example, re-write `process.env.TSS_APP_BASE` in the `.js` client side bundle)
+          NODE_ENV: "development",
         },
-        cwd: paths.cwd,
       });
     }
 
@@ -348,104 +368,3 @@ async function writeMiniflareSymlink(cwd: string) {
     }
   });
 }
-
-async function runDevCommand(
-  scope: Scope,
-  props: {
-    id: string;
-    command: string;
-    env: Record<string, string | Secret<string> | undefined>;
-    cwd?: string;
-  },
-) {
-  const persistFile = path.join(process.cwd(), ".alchemy", `${props.id}.pid`);
-  if (await exists(persistFile)) {
-    const pid = Number.parseInt(await fs.readFile(persistFile, "utf8"));
-    try {
-      // Actually kill the process if it's alive
-      process.kill(pid, "SIGTERM");
-    } catch {
-      // ignore
-    }
-    try {
-      await fs.unlink(persistFile);
-    } catch {
-      // ignore
-    }
-  }
-  const command = props.command.split(" ");
-  const [cmd, ...args] = command;
-
-  const childProcess = spawn(cmd, args, {
-    cwd: props.cwd,
-    shell: true,
-    env: {
-      FORCE_COLOR: "1",
-      ...process.env,
-      ...Object.fromEntries(
-        Object.entries(props.env ?? {}).flatMap(([key, value]) => {
-          if (isSecret(value)) {
-            return [[key, value.unencrypted]];
-          }
-          if (typeof value === "string") {
-            return [[key, value]];
-          }
-          return [];
-        }),
-      ),
-      // NOTE: we must set this to ensure the user does not accidentally set `NODE_ENV=production`
-      // which breaks `vite dev` (it won't, for example, re-write `process.env.TSS_APP_BASE` in the `.js` client side bundle)
-      NODE_ENV: "development",
-    },
-    stdio: "pipe",
-  });
-  await once(childProcess, "spawn");
-  scope.onCleanup(async () => {
-    if (childProcess.exitCode === null && !childProcess.killed) {
-      childProcess.kill("SIGTERM");
-      await Promise.any([
-        once(childProcess, "exit"),
-        new Promise((resolve) => setTimeout(resolve, 5000)),
-      ]);
-      if (!childProcess.killed) {
-        childProcess.kill("SIGKILL");
-      }
-    }
-    try {
-      await fs.unlink(persistFile);
-    } catch {
-      // ignore
-    }
-  });
-  if (childProcess.pid) {
-    await fs.mkdir(path.dirname(persistFile), { recursive: true });
-    await fs.writeFile(persistFile, childProcess.pid.toString());
-  }
-  const URL_REGEX =
-    /http:\/\/(?:(?:localhost|0\.0\.0\.0|127\.0\.0\.1)|(?:\d{1,3}\.){3}\d{1,3}):\d+(?:\/)?/;
-  const promise = new DeferredPromise<string>();
-  childProcess.stdout.on("data", (data) => {
-    if (promise.status === "pending") {
-      const match = data
-        .toString()
-        .replace(/\x1B\[[0-9;]*[a-zA-Z]/g, "")
-        .match(URL_REGEX);
-      if (match) {
-        promise.resolve(match[0]);
-      }
-    }
-    process.stdout.write(data);
-  });
-  childProcess.stderr.on("data", (data) => {
-    process.stderr.write(data);
-  });
-
-  return await Promise.race([
-    promise.value,
-    once(childProcess, "exit").then(([code, signal]) => {
-      throw new Error(
-        `Dev command "${props.command}" for "${props.id}" failed to start (code: ${code}, signal: ${signal})`,
-      );
-    }),
-  ]);
-}

package/src/cloudflare/worker-bundle.ts

@@ -1,4 +1,5 @@
 import esbuild from "esbuild";
+import { globIterate } from "glob";
 import { err, ok, type Result } from "neverthrow";
 import fs from "node:fs/promises";
 import path from "pathe";
@@ -92,21 +93,22 @@ export namespace WorkerBundle {
     paths: string[],
     format: "esm" | "cjs",
   ): WorkerBundle.Module[] => {
-    return paths.map((path) => {
-      const ext = path.split(".").pop();
+    return paths.map((filePath) => {
+      const normalizedPath = path.normalize(filePath);
+      const ext = normalizedPath.split(".").pop();
       switch (ext) {
         case "js":
-          return { type: format, path };
+          return { type: format, path: normalizedPath };
         case "mjs":
-          return { type: "esm", path };
+          return { type: "esm", path: normalizedPath };
         case "cjs":
-          return { type: "cjs", path };
+          return { type: "cjs", path: normalizedPath };
         case "wasm":
-          return { type: "wasm", path };
+          return { type: "wasm", path: normalizedPath };
         case "map":
-          return { type: "sourcemap", path };
+          return { type: "sourcemap", path: normalizedPath };
         default:
-          return { type: "text", path };
+          return { type: "text", path: normalizedPath };
       }
     });
   };
@@ -222,7 +224,7 @@ export namespace WorkerBundleSource {
       const fileNames = new Set<string>();
       await Promise.all(
         this.globs.map(async (glob) => {
-          for await (const file of fs.glob(glob, { cwd: this.root })) {
+          for await (const file of globIterate(glob, { cwd: this.root })) {
             fileNames.add(file);
           }
         }),

package/src/cloudflare/worker-tail.ts

@@ -1,4 +1,4 @@
-import kleur from "kleur";
+import pc from "picocolors";
 import { WebSocket } from "ws";
 import { logger } from "../util/logger.ts";
 import type { CloudflareApiResponse } from "./api-response.ts";
@@ -102,7 +102,7 @@ class TailClient {
     });
     ws.on("message", (message) => {
       const data: TailEventMessage = JSON.parse(message.toString());
-      const prefix = kleur.blue(`[${this.id}]`);
+      const prefix = pc.blue(`[${this.id}]`);
       if (data.event && "request" in data.event) {
         // TODO: handle other event types
         const event = data.event;
@@ -110,18 +110,16 @@ class TailClient {
         const status = event.response?.status ?? 500;
         // TODO: make this look nicer
         logger.log(
-          `${prefix} ${kleur.gray(event.request.method)} ${url.pathname} ${kleur.dim(">")} ${status >= 200 && status < 300 ? kleur.green(status) : kleur.red(status)} ${kleur.gray(`(cpu: ${Math.round(data.cpuTime)}ms, wall: ${Math.round(data.wallTime)}ms)`)}`,
+          `${prefix} ${pc.gray(event.request.method)} ${url.pathname} ${pc.dim(">")} ${status >= 200 && status < 300 ? pc.green(status) : pc.red(status)} ${pc.gray(`(cpu: ${Math.round(data.cpuTime)}ms, wall: ${Math.round(data.wallTime)}ms)`)}`,
         );
       }
       for (const log of data.logs) {
-        logger.log(
-          `${prefix} ${kleur.gray(log.level)} ${log.message.join(" ")}`,
-        );
+        logger.log(`${prefix} ${pc.gray(log.level)} ${log.message.join(" ")}`);
       }
       for (const exception of data.exceptions) {
-        const start = `${prefix} ${kleur.red(exception.name)}`;
+        const start = `${prefix} ${pc.red(exception.name)}`;
         logger.log(
-          `${start} ${exception.message}\n${kleur.gray(exception.stack)}`,
+          `${start} ${exception.message}\n${pc.gray(exception.stack)}`,
         );
       }
     });