alchemy 0.74.1 → 0.75.0

package/src/cloudflare/bun-spa/bun-spa.ts

@@ -1,5 +1,5 @@
 import fs from "node:fs/promises";
-import path from "node:path";
+import path from "pathe";
 import { Scope } from "../../scope.ts";
 import { exists } from "../../util/exists.ts";
 import type { Bindings } from "../bindings.ts";
@@ -18,7 +18,7 @@ export interface BunSPAProps<B extends Bindings> extends WebsiteProps<B> {
   /**
    * The path to the frontend entrypoints that bun should bundle for deployment & serve in dev mode.
    * These are usually html files. Glob patterns are supported.
-   * Typically set to index.html
+   * Typically set to src/index.html
    */
   frontend: string | string[];
   outDir?: string;
@@ -70,6 +70,8 @@ export async function BunSPA<B extends Bindings>(
   }
 
   const scope = Scope.current;
+  const nodeEnv =
+    (props.bindings?.NODE_ENV ?? scope.local) ? "development" : "production";
   console.log("creating website", outDir);
   const website = await Website(id, {
     spa: true,
@@ -77,17 +79,14 @@ export async function BunSPA<B extends Bindings>(
     bindings: {
       ...props.bindings,
       // set NODE_ENV in worker appropriately if not already set
-      NODE_ENV:
-        (props.bindings?.NODE_ENV ?? scope.local)
-          ? "development"
-          : "production",
+      NODE_ENV: nodeEnv,
     } as unknown as B,
     assets: {
       directory: path.resolve(outDir),
     },
     build: spreadBuildProps(
       props,
-      `bun build '${frontendPaths.join("' '")}' --outdir ${outDir}`,
+      `bun build '${frontendPaths.join("' '")}' --target=browser --minify --define:process.env.NODE_ENV='"${nodeEnv}"' --env='BUN_PUBLIC_*' --outdir ${outDir}`,
     ),
   });
 
@@ -129,7 +128,7 @@ export async function BunSPA<B extends Bindings>(
         ...process.env,
         NODE_ENV: "development",
         ALCHEMY_ROOT: Scope.current.rootDir,
-        PUBLIC_BACKEND_URL: apiUrl,
+        BUN_PUBLIC_BACKEND_URL: apiUrl,
       },
     });
   }
@@ -144,8 +143,8 @@ async function validateBunfigToml(cwd: string): Promise<void> {
       "bunfig.toml is required for BunSPA to work correctly.\n\n" +
         `Create ${bunfigPath} with the following content:\n\n` +
         "[serve.static]\n" +
-        `env='PUBLIC_*'\n\n` +
-        "This allows Bun to expose PUBLIC_* environment variables to the frontend during development.",
+        `env='BUN_PUBLIC_*'\n\n` +
+        "This allows Bun to expose BUN_PUBLIC_* environment variables to the frontend during development.",
     );
   }
 
@@ -153,15 +152,16 @@ async function validateBunfigToml(cwd: string): Promise<void> {
   const config = Bun.TOML.parse(content) as Record<string, any>;
 
   const hasServeStatic = config.serve?.static;
-  const hasEnvConfig = hasServeStatic && config.serve.static.env === "PUBLIC_*";
+  const hasEnvConfig =
+    hasServeStatic && config.serve.static.env === "BUN_PUBLIC_*";
 
   if (!hasServeStatic || !hasEnvConfig) {
     throw new Error(
       "bunfig.toml is missing required configuration for BunSPA.\n\n" +
         `Add the following section to ${bunfigPath}:\n\n` +
         "[serve.static]\n" +
-        `env='PUBLIC_*'\n\n` +
-        "This allows Bun to expose PUBLIC_* environment variables to the frontend during development.",
+        `env='BUN_PUBLIC_*'\n\n` +
+        "This allows Bun to expose BUN_PUBLIC_* environment variables to the frontend during development.",
     );
   }
 }

package/src/cloudflare/bun-spa/get-bun-spa-backend.ts

@@ -0,0 +1,29 @@
+type GetBackendUrlProps = {
+  // If you're using routes with paths in your worker configuration, you'll need to pass the path you want to use here, e.g. "/api"
+  routePath?: string;
+};
+
+/**
+ * Use this function in your frontend code to automatically get the correct URL for your backend API in both local and deployed environments
+ * @param param0 { path: string }
+ * @returns
+ */
+export function getBackendUrl({ routePath }: GetBackendUrlProps = {}): URL {
+  let pathToUse = !routePath
+    ? "/"
+    : routePath.startsWith("/")
+      ? routePath
+      : `/${routePath}`;
+  // This is ugly but it's necessary to support both local and prod environments
+  // Start with the current host
+  let backendUrl = `${window.location.protocol}//${window.location.host}${pathToUse}`;
+  try {
+    // Bun will only inline this if we use exactly `process.env.BUN_PUBLIC_BACKEND_URL` it we use other forms including process?.env for example bun will not inline it
+    // we can't check typeof process either because process may not be available but Bun may already have inlined process.env.BUN_PUBLIC_BACKEND_URL with the correct value
+    backendUrl = process.env.BUN_PUBLIC_BACKEND_URL ?? backendUrl;
+  } catch {
+    // Bun may not have had anything to inline and process.env may not exist to above can throw an error
+    // do nothing
+  }
+  return new URL(backendUrl);
+}

package/src/cloudflare/bun-spa/index.ts

@@ -0,0 +1 @@
+export * from "./get-bun-spa-backend.ts";

package/src/cloudflare/bundle/internal-worker-bundle.ts

@@ -1,6 +1,6 @@
 import crypto from "node:crypto";
 import fs from "node:fs/promises";
-import path from "node:path";
+import path from "pathe";
 import { memoize } from "../../util/memoize.ts";
 import type { WorkerBundle } from "../worker-bundle.ts";
 

package/src/cloudflare/bundle/plugin-hybrid-node-compat.ts

@@ -5,7 +5,7 @@
 import type { Plugin, PluginBuild } from "esbuild";
 import assert from "node:assert";
 import { createRequire } from "node:module";
-import nodePath from "node:path";
+import nodePath from "pathe";
 import { dedent } from "../../util/dedent.ts";
 import { NODEJS_MODULES_RE } from "./nodejs-builtin-modules.ts";
 

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

@@ -1,6 +1,6 @@
 import type { Plugin } from "esbuild";
 import type { NodeJSCompatMode } from "miniflare";
-import { relative } from "node:path";
+import { relative } from "pathe";
 import pc from "picocolors";
 import { dedent } from "../../util/dedent.ts";
 import { logger } from "../../util/logger.ts";

package/src/cloudflare/bundle/plugin-wasm.ts

@@ -1,7 +1,7 @@
 import type esbuild from "esbuild";
 import assert from "node:assert";
 import fs from "node:fs/promises";
-import path from "node:path";
+import path from "pathe";
 import type { WorkerBundle } from "../worker-bundle.ts";
 
 export function createWasmPlugin() {

package/src/cloudflare/d1-migrations.ts

@@ -1,6 +1,6 @@
 import { glob } from "glob";
 import * as fs from "node:fs/promises";
-import * as path from "node:path";
+import path from "pathe";
 import { logger } from "../util/logger.ts";
 import { handleApiError } from "./api-error.ts";
 import type { CloudflareApi } from "./api.ts";

package/src/cloudflare/kv-namespace.ts

@@ -13,6 +13,8 @@ import {
   type CloudflareApiOptions,
 } from "./api.ts";
 import { deleteMiniflareBinding } from "./miniflare/delete.ts";
+import * as mf from "miniflare";
+import { getDefaultPersistPath } from "./miniflare/paths.ts";
 
 /**
  * Properties for creating or updating a KV Namespace
@@ -220,6 +222,13 @@ const _KVNamespace = Resource(
     };
 
     if (local) {
+      if (props.values) {
+        await insertLocalKVRecords({
+          namespaceId: dev.id,
+          values: props.values,
+          rootDir: this.scope.rootDir,
+        });
+      }
       return {
         type: "kv_namespace",
         namespaceId: this.output?.namespaceId ?? "",
@@ -340,31 +349,18 @@ export async function insertKVRecords(
     const BATCH_SIZE = 10000;
 
     for (let i = 0; i < props.values.length; i += BATCH_SIZE) {
-      const batch = props.values.slice(i, i + BATCH_SIZE);
-
-      const bulkPayload = batch.map((entry) => {
-        const item: any = {
+      const bulkPayload = props.values
+        .slice(i, i + BATCH_SIZE)
+        .map((entry) => ({
           key: entry.key,
           value:
             typeof entry.value === "string"
               ? entry.value
               : JSON.stringify(entry.value),
-        };
-
-        if (entry.expiration) {
-          item.expiration = entry.expiration;
-        }
-
-        if (entry.expirationTtl) {
-          item.expiration_ttl = entry.expirationTtl;
-        }
-
-        if (entry.metadata) {
-          item.metadata = entry.metadata;
-        }
-
-        return item;
-      });
+          expiration: entry.expiration,
+          expiration_ttl: entry.expirationTtl,
+          metadata: entry.metadata,
+        }));
 
       await withExponentialBackoff(
         async () => {
@@ -397,6 +393,42 @@ export async function insertKVRecords(
   }
 }
 
+export async function insertLocalKVRecords(input: {
+  namespaceId: string;
+  values: KVPair[];
+  rootDir: string;
+}) {
+  const miniflare = new mf.Miniflare({
+    script: "",
+    modules: true,
+    defaultPersistRoot: getDefaultPersistPath(input.rootDir),
+    kvNamespaces: { KV: input.namespaceId },
+    kvPersist: true,
+    log: process.env.DEBUG ? new mf.Log(mf.LogLevel.DEBUG) : undefined,
+  });
+  try {
+    await miniflare.ready;
+    const kv = await miniflare.getKVNamespace("KV");
+    await Promise.all(
+      input.values.map((record) =>
+        kv.put(
+          record.key,
+          typeof record.value === "string"
+            ? record.value
+            : JSON.stringify(record.value),
+          {
+            expiration: record.expiration,
+            expirationTtl: record.expirationTtl,
+            metadata: record.metadata,
+          },
+        ),
+      ),
+    );
+  } finally {
+    await miniflare.dispose();
+  }
+}
+
 /**
  * Interface representing a KV namespace as returned by Cloudflare API
  */

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

@@ -1,6 +1,6 @@
 import * as miniflare from "miniflare";
 import assert from "node:assert";
-import path from "node:path";
+import path from "pathe";
 import { Scope } from "../../scope.ts";
 import { findOpenPort } from "../../util/find-open-port.ts";
 import type { HTTPServer } from "../../util/http.ts";

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

@@ -1,9 +1,11 @@
 import * as miniflare from "miniflare";
+import assert from "node:assert";
 import { once } from "node:events";
 import http from "node:http";
 import { Readable } from "node:stream";
 import { WebSocket, WebSocketServer } from "ws";
 import { createUpgradeHandler } from "../../util/http.ts";
+import { logger } from "../../util/logger.ts";
 
 export interface MiniflareWorkerProxy {
   url: URL;
@@ -90,12 +92,10 @@ export async function createMiniflareWorkerProxy(options: {
     });
   };
 
-  server.listen(options.port);
-  await once(server, "listening");
-  const url = new URL(`http://localhost:${options.port}`);
+  await listen(server, options.port);
 
   return {
-    url,
+    url: getAddress(server),
     close: async () => {
       // If we await this while the `wss` server is open, the server will hang.
       server.close();
@@ -103,6 +103,41 @@ export async function createMiniflareWorkerProxy(options: {
   };
 }
 
+/**
+ * Listens on the given port, retrying on the next port if the port is already in use.
+ */
+async function listen(server: http.Server, port: number) {
+  try {
+    server.listen(port);
+    await once(server, "listening");
+  } catch (error) {
+    if (
+      typeof error === "object" &&
+      error !== null &&
+      "code" in error &&
+      error.code === "EADDRINUSE"
+    ) {
+      logger.warn(`Port ${port} is already in use, trying ${port + 1}...`);
+      await listen(server, port + 1);
+    } else {
+      throw error;
+    }
+  }
+}
+
+function getAddress(server: http.Server) {
+  const address = server.address();
+  assert(
+    address &&
+      typeof address === "object" &&
+      "address" in address &&
+      "port" in address,
+    "Server is not listening",
+  );
+  const hostname = address.address === "::" ? "localhost" : address.address;
+  return new URL(`http://${hostname}:${address.port}`);
+}
+
 interface RequestInfo {
   method: string;
   url: URL;

package/src/cloudflare/miniflare/paths.ts

@@ -1,6 +1,7 @@
 import { AsyncLocalStorage } from "node:async_hooks";
+// biome-ignore lint/style/noRestrictedImports: I/O is acceptable here
 import { existsSync, readlinkSync, statSync } from "node:fs";
-import path from "node:path";
+import path from "pathe";
 import { ALCHEMY_ROOT } from "../../util/root-dir.ts";
 
 const dynamicImportContext = new AsyncLocalStorage<boolean>();

package/src/cloudflare/miniflare/symlink-miniflare-state.ts

@@ -1,5 +1,5 @@
 import fs from "node:fs/promises";
-import path from "node:path";
+import path from "pathe";
 import { getDefaultPersistPath } from "./paths.ts";
 
 export async function writeMiniflareSymlink(rootDir: string, cwd: string) {

package/src/cloudflare/next.ts

@@ -1,5 +1,5 @@
 import * as fs from "node:fs/promises";
-import path from "node:path";
+import path from "pathe";
 import pc from "picocolors";
 import { getPackageManagerRunner } from "../util/detect-package-manager.ts";
 import { exists } from "../util/exists.ts";

package/src/cloudflare/nuxt/nuxt.ts

@@ -1,4 +1,4 @@
-import path from "node:path";
+import path from "pathe";
 import { getPackageManagerRunner } from "../../util/detect-package-manager.ts";
 import type { Assets } from "../assets.ts";
 import type { Bindings } from "../bindings.ts";

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

@@ -1,6 +1,7 @@
 import type { PluginConfig } from "@cloudflare/vite-plugin";
+// biome-ignore lint/style/noRestrictedImports: I/O is acceptable here
 import { existsSync, mkdirSync, writeFileSync } from "node:fs";
-import { dirname } from "node:path";
+import { dirname } from "pathe";
 import { getDefaultConfigPath } from "../miniflare/paths.ts";
 import alchemyVite from "../vite/plugin.ts";
 

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

@@ -1,4 +1,4 @@
-import path from "node:path";
+import path from "pathe";
 import { getPackageManagerRunner } from "../../util/detect-package-manager.ts";
 import type { Assets } from "../assets.ts";
 import type { Bindings } from "../bindings.ts";

package/src/cloudflare/redwood/redwood.ts

@@ -1,4 +1,4 @@
-import path from "node:path";
+import path from "pathe";
 import type { Assets } from "../assets.ts";
 import type { Bindings } from "../bindings.ts";
 import { Vite, type ViteProps } from "../vite/vite.ts";

package/src/cloudflare/sveltekit/sveltekit.ts

@@ -1,4 +1,4 @@
-import { join } from "node:path";
+import { join } from "pathe";
 import type { Assets } from "../assets.ts";
 import type { Bindings } from "../bindings.ts";
 import { Vite, type ViteProps } from "../vite/vite.ts";

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

@@ -1,4 +1,4 @@
-import path from "node:path";
+import path from "pathe";
 import { exists } from "../../util/exists.ts";
 import type { Assets } from "../assets.ts";
 import type { Bindings } from "../bindings.ts";

package/src/cloudflare/tunnel.ts

@@ -494,6 +494,9 @@ export const Tunnel = Resource(
     const name =
       props.name ?? this.output?.name ?? this.scope.createPhysicalName(id);
 
+    // Track if we're replacing the tunnel (don't fetch token in this case)
+    let isReplacing = false;
+
     if (this.phase === "update" && this.output.name !== name) {
       console.log("replacing tunnel", this.output.name, name);
       this.replace(true);
@@ -563,7 +566,6 @@ export const Tunnel = Resource(
           (error.message.includes("already have a tunnel with this name") ||
             error.message.includes("already exists"))
         ) {
-          console.log(error);
           logger.log(`Tunnel '${name}' already exists, adopting it`);
 
           // Find the existing tunnel by name
@@ -596,6 +598,12 @@ export const Tunnel = Resource(
       }
     }
 
+    // Ensure tunnel token is available (unless we're replacing)
+    // Sometimes Cloudflare doesn't return the token in the initial response
+    if (!isReplacing && !tunnelData.token) {
+      tunnelData.token = await getTunnelToken(api, tunnelData.id);
+    }
+
     // Handle DNS records for ingress hostnames
     let dnsRecords = this.output?.dnsRecords || {};
 
@@ -918,3 +926,30 @@ export async function findTunnelByName(
   // No matching tunnel found
   return null;
 }
+
+/**
+ * Get tunnel token
+ */
+async function getTunnelToken(
+  api: CloudflareApi,
+  tunnelId: string,
+): Promise<string> {
+  const response = await api.get(
+    `/accounts/${api.accountId}/cfd_tunnel/${tunnelId}/token`,
+  );
+
+  if (!response.ok) {
+    logger.error(
+      `Failed to fetch token for tunnel ${tunnelId}: ${response.status} ${response.statusText}`,
+    );
+    await handleApiError(response, "get token", "tunnel", tunnelId);
+  }
+
+  const data = (await response.json()) as CloudflareApiResponse<string>;
+  if (!data.result) {
+    logger.warn(`Could not retrieve token for tunnel ${tunnelId}`);
+  } else {
+    logger.log(`Successfully fetched token for tunnel ${tunnelId}`);
+  }
+  return data.result;
+}

package/src/cloudflare/vite/plugin.ts

@@ -1,5 +1,5 @@
 import { cloudflare, type PluginConfig } from "@cloudflare/vite-plugin";
-import path from "node:path";
+import path from "pathe";
 import type { PluginOption } from "vite";
 import {
   getDefaultConfigPath,

package/src/cloudflare/website.ts

@@ -1,6 +1,6 @@
 import assert from "node:assert";
 import fs from "node:fs/promises";
-import path from "node:path";
+import path from "pathe";
 import { Exec } from "../os/index.ts";
 import { Scope } from "../scope.ts";
 import { dedent } from "../util/dedent.ts";

package/src/cloudflare/worker.ts

@@ -34,6 +34,7 @@ import {
 } from "./durable-object-namespace.ts";
 import { type EventSource, isQueueEventSource } from "./event-source.ts";
 import { deleteMiniflareWorkerData } from "./miniflare/delete.ts";
+import { MiniflareController } from "./miniflare/miniflare-controller.ts";
 import {
   QueueConsumer,
   deleteQueueConsumer,
@@ -966,9 +967,6 @@ const _Worker = Resource(
       if (props.dev?.url) {
         url = props.dev.url;
       } else {
-        const { MiniflareController } = await import(
-          "./miniflare/miniflare-controller.js"
-        );
         const controller = MiniflareController.singleton;
         url = await controller.add({
           api,

package/src/cloudflare/wrangler.json.ts

@@ -1,5 +1,5 @@
 import fs from "node:fs/promises";
-import path from "node:path";
+import path from "pathe";
 import type { Context } from "../context.ts";
 import { Resource } from "../resource.ts";
 import { Scope } from "../scope.ts";

package/src/coinbase/faucet.ts

@@ -8,9 +8,9 @@
  *   bun node_modules/alchemy/src/coinbase/faucet.ts backend/dev  # Fund specific scope
  */
 
-import { readFile, access } from "node:fs/promises";
-import { join } from "node:path";
 import { glob } from "glob";
+import { access, readFile } from "node:fs/promises";
+import { join } from "pathe";
 import { createCdpClient } from "./client.ts";
 import type { EvmAccount } from "./evm-account.ts";
 import type { EvmSmartAccount } from "./evm-smart-account.ts";

package/src/docker/api.ts

@@ -2,7 +2,7 @@ import { execa } from "execa";
 import { Buffer } from "node:buffer";
 import { spawn } from "node:child_process";
 import fs from "node:fs/promises";
-import path from "node:path";
+import path from "pathe";
 import type { Duration, HealthcheckConfig } from "./container.ts";
 
 /**

package/src/docker/image.ts

@@ -1,6 +1,6 @@
 import fs from "node:fs/promises";
 import os from "node:os";
-import path from "node:path";
+import path from "pathe";
 import type { Context } from "../context.ts";
 import { Resource } from "../resource.ts";
 import type { Secret } from "../secret.ts";

package/src/docker/volume.ts

@@ -135,13 +135,13 @@ export const Volume = Resource(
       return this.destroy();
     } else {
       // Set default driver if not provided
-      props.driver = props.driver || "local";
+      const driver = props.driver || "local";
       const driverOpts = props.driverOpts || {};
 
       // Create the volume
       const volumeId = await api.createVolume(
         volumeName,
-        props.driver,
+        driver,
         driverOpts,
         processedLabels,
       );
@@ -152,6 +152,7 @@ export const Volume = Resource(
 
       return {
         ...props,
+        driver: driver,
         id: volumeId,
         name: volumeName,
         mountpoint,

package/src/esbuild/bundle.ts

@@ -1,7 +1,7 @@
 import type esbuild from "esbuild";
 import crypto from "node:crypto";
 import fs from "node:fs/promises";
-import path from "node:path";
+import path from "pathe";
 import type { Context } from "../context.ts";
 import { Resource } from "../resource.ts";
 import { logger } from "../util/logger.ts";

package/src/fs/file.ts

@@ -1,5 +1,5 @@
 import fs from "node:fs";
-import path from "node:path";
+import path from "pathe";
 import type { Context } from "../context.ts";
 import { Resource } from "../resource.ts";
 import { ignore } from "../util/ignore.ts";

package/src/llms.ts

@@ -1,5 +1,5 @@
 import fs from "node:fs/promises";
-import path from "node:path";
+import path from "pathe";
 
 export interface AlchemyRule {
   name: string;

package/src/os/exec.ts

@@ -1,6 +1,6 @@
 import { spawn, type SpawnOptions } from "node:child_process";
 import { createHash } from "node:crypto";
-import { join } from "node:path";
+import { join } from "pathe";
 import type { Context } from "../context.ts";
 import { Resource } from "../resource.ts";
 import type { Secret } from "../secret.ts";

package/src/scope.ts

@@ -1,6 +1,6 @@
 import { AsyncLocalStorage } from "node:async_hooks";
-import path from "node:path";
 import util from "node:util";
+import path from "pathe";
 import pc from "picocolors";
 import type { Phase } from "./alchemy.ts";
 import { destroy, destroyAll, DestroyStrategy } from "./destroy.ts";

package/src/state/file-system-state-store.ts

@@ -1,5 +1,5 @@
 import fs from "node:fs";
-import path from "node:path";
+import path from "pathe";
 import { ResourceScope } from "../resource.ts";
 import type { Scope } from "../scope.ts";
 import { deserialize, serialize } from "../serde.ts";

package/src/state/migrations.ts

@@ -1,4 +1,4 @@
-import path from "node:path";
+import path from "pathe";
 
 export const MIGRATIONS_DIRECTORY = path.join(
   import.meta.dirname,

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

@@ -1,6 +1,6 @@
 import type { Config as LibSQLConfig } from "@libsql/client";
 import fs from "node:fs/promises";
-import path from "node:path";
+import path from "pathe";
 import type { Scope } from "../scope.ts";
 import { exists } from "../util/exists.ts";
 import { memoize } from "../util/memoize.ts";