alchemy 0.49.0 → 0.50.0

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-07-18";
+export const DEFAULT_COMPATIBILITY_DATE = "2025-07-19";

package/src/cloudflare/nuxt.ts

@@ -55,7 +55,7 @@ export async function Nuxt<B extends Bindings>(
     ...props,
     noBundle: props?.noBundle ?? true,
     // Default build command, can be overridden by props.command
-    command: props?.command ?? "bun run build",
+    command: props?.command ?? "nuxt build",
     // Default entry point for cloudflare-module preset
     main: props?.main ?? "./.output/server/index.mjs",
     // Default static assets directory for cloudflare-module preset

package/src/cloudflare/orange.ts

@@ -40,7 +40,10 @@ export async function Orange<B extends Bindings>(
 ): Promise<Orange<B>> {
   return Website(id, {
     ...props,
-    command: props?.command ?? "bun run build",
+    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.

package/src/cloudflare/redwood.ts

@@ -43,7 +43,12 @@ export async function Redwood<B extends Bindings>(
 ): Promise<Redwood<B>> {
   return Website(id, {
     ...props,
-    command: props?.command ?? "bun run clean && RWSDK_DEPLOY=1 bun run build",
+    command:
+      props?.command ??
+      "rm -rf ./node_modules/.vite && RWSDK_DEPLOY=1 vite build",
+    dev: props?.dev ?? {
+      command: "vite dev",
+    },
     noBundle: props?.noBundle ?? true,
     wrangler:
       props?.wrangler === false

package/src/cloudflare/route.ts

@@ -282,6 +282,10 @@ async function updateRoute(
     },
   );
 
+  if (updateResponse.status === 404) {
+    return await createRoute(api, zoneId, pattern, script);
+  }
+
   if (!updateResponse.ok) {
     return await handleApiError(updateResponse, "updating", "Route", pattern);
   }

package/src/cloudflare/vite.ts

@@ -1,5 +1,4 @@
 import path from "node:path";
-import { detectPackageManager } 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";
@@ -18,14 +17,6 @@ export async function Vite<B extends Bindings>(
   props: ViteProps<B>,
 ): Promise<Vite<B>> {
   const defaultAssets = path.join("dist", "client");
-  const packageManager = await detectPackageManager();
-  const devCommand = {
-    npm: "npx vite dev",
-    bun: "bun vite dev",
-    pnpm: "pnpm vite dev",
-    yarn: "yarn vite dev",
-    deno: "deno vite dev",
-  }[packageManager];
   return Website(id, {
     ...props,
     spa: true,
@@ -36,8 +27,9 @@ export async function Vite<B extends Bindings>(
             dist: props.assets.dist ?? defaultAssets,
           }
         : (props.assets ?? defaultAssets),
+    command: props.command ?? "vite build",
     dev: props.dev ?? {
-      command: devCommand,
+      command: "vite dev",
     },
   });
 }

package/src/cloudflare/website.ts

@@ -231,6 +231,7 @@ export default {
           cwd,
           command: props.command,
           env: {
+            ...(process.env ?? {}),
             ...(props.env ?? {}),
             ...(props.commandEnv ?? {}),
             ...Object.fromEntries(

package/src/cloudflare/worker.ts

@@ -1088,6 +1088,7 @@ export const _Worker = Resource(
           command: props.dev.command,
           cwd: props.dev.cwd || props.cwd || process.cwd(),
           env: {
+            ...(process.env ?? {}),
             ...props.env,
             ...Object.fromEntries(
               Object.entries(props.bindings ?? {}).flatMap(([key, value]) =>
@@ -1834,7 +1835,7 @@ async function createDevCommand(props: {
   id: string;
   command: string;
   cwd: string;
-  env: Record<string, string>;
+  env: Record<string, string | undefined>;
 }): Promise<{ url: string }> {
   const persistFile = path.join(process.cwd(), ".alchemy", `${props.id}.pid`);
   if (await exists(persistFile)) {

package/src/destroy.ts

@@ -16,9 +16,13 @@ import { logger } from "./util/logger.ts";
 
 export class DestroyedSignal extends Error {}
 
+export type DestroyStrategy = "sequential" | "parallel";
+
+export const DestroyStrategy = Symbol.for("alchemy::DestroyStrategy");
+
 export interface DestroyOptions {
   quiet?: boolean;
-  strategy?: "sequential" | "parallel";
+  strategy?: DestroyStrategy;
   replace?: {
     props?: ResourceProps | undefined;
     output?: Resource<string>;
@@ -40,7 +44,7 @@ export async function destroy<Type extends string>(
   if (isScopeArgs(args)) {
     const [scope] = args;
     const options = {
-      strategy: "sequential",
+      strategy: scope.destroyStrategy ?? "sequential",
       ...(args[1] ?? {}),
     } satisfies DestroyOptions;
 
@@ -118,7 +122,20 @@ export async function destroy<Type extends string>(
       fqn: instance[ResourceFQN],
       seq: instance[ResourceSeq],
       props: options?.replace?.props ?? state.props,
-      state,
+      state: options?.replace?.output
+        ? {
+            output: options.replace.output,
+            status: "deleting",
+            oldProps: options.replace.props,
+            data: {},
+            kind: instance[ResourceKind],
+            id: instance[ResourceID],
+            fqn: instance[ResourceFQN],
+            seq: instance[ResourceSeq],
+            props: options.replace.props,
+          }
+        : state,
+      // TODO(sam|michael): should this always be false or !!options?.replace
       isReplacement: false,
       replace: () => {
         throw new Error("Cannot replace a resource that is being deleted");
@@ -134,6 +151,7 @@ export async function destroy<Type extends string>(
           // TODO(sam): this is an awful hack to differentiate between naked scopes and resources
           isResource: instance[ResourceKind] !== "alchemy::Scope",
           parent: scope,
+          destroyStrategy: instance[DestroyStrategy] ?? "sequential",
         },
         async (scope) => {
           nestedScope = options?.replace?.props == null ? scope : undefined;
@@ -151,13 +169,17 @@ export async function destroy<Type extends string>(
       }
     }
 
+    const destroyOptions = {
+      ...options,
+      strategy: instance[DestroyStrategy] ?? "sequential",
+    };
     if (nestedScope) {
-      await destroy(nestedScope, options);
+      await destroy(nestedScope, destroyOptions);
     }
 
     if (options?.replace == null) {
       if (nestedScope) {
-        await destroy(nestedScope, options);
+        await destroy(nestedScope, destroyOptions);
       }
       await scope.deleteResource(instance[ResourceID]);
     } else {

package/src/os/exec.ts

@@ -48,7 +48,7 @@ export interface ExecProps {
   /**
    * Environment variables to set
    */
-  env?: Record<string, string | Secret<string>>;
+  env?: Record<string, string | Secret<string> | undefined>;
 
   /**
    * Whether to inherit stdio from parent process
@@ -218,7 +218,7 @@ export const Exec = Resource(
         for (const [key, value] of Object.entries(props.env)) {
           if (typeof value === "string") {
             processedEnv[key] = value;
-          } else {
+          } else if (value) {
             // Handle Secret objects
             processedEnv[key] = value.unencrypted;
           }

package/src/resource.ts

@@ -1,5 +1,6 @@
 import { apply } from "./apply.ts";
 import type { Context } from "./context.ts";
+import { DestroyStrategy } from "./destroy.ts";
 import { Scope as _Scope, type Scope } from "./scope.ts";
 
 declare global {
@@ -59,6 +60,13 @@ export interface ProviderOptions {
    * If true, the resource will be updated even if the inputs have not changed.
    */
   alwaysUpdate: boolean;
+
+  /**
+   * The strategy to use when destroying the resource.
+   *
+   * @default "sequential"
+   */
+  destroyStrategy?: DestroyStrategy;
 }
 
 export type ResourceProps = {
@@ -81,6 +89,7 @@ export interface PendingResource<Out = unknown> extends Promise<Out> {
   [ResourceFQN]: ResourceFQN;
   [ResourceScope]: Scope;
   [ResourceSeq]: number;
+  [DestroyStrategy]: DestroyStrategy;
   [InnerResourceScope]: Promise<Scope>;
 }
 
@@ -90,6 +99,7 @@ export interface Resource<Kind extends ResourceKind = ResourceKind> {
   [ResourceFQN]: ResourceFQN;
   [ResourceScope]: Scope;
   [ResourceSeq]: number;
+  [DestroyStrategy]: DestroyStrategy;
 }
 
 // helper for semantic syntax highlighting (color as a type/class instead of function/value)
@@ -167,6 +177,7 @@ export function Resource<
       [ResourceFQN]: scope.fqn(resourceID),
       [ResourceSeq]: seq,
       [ResourceScope]: scope,
+      [DestroyStrategy]: options?.destroyStrategy ?? "sequential",
       [InnerResourceScope]: new Promise<Scope>((resolve) => {
         resolveInnerScope = resolve;
       }),

package/src/scope.ts

@@ -1,7 +1,7 @@
 import { AsyncLocalStorage } from "node:async_hooks";
 import util from "node:util";
 import type { Phase } from "./alchemy.ts";
-import { destroy, destroyAll } from "./destroy.ts";
+import { destroy, destroyAll, DestroyStrategy } from "./destroy.ts";
 import {
   ResourceFQN,
   ResourceID,
@@ -56,6 +56,12 @@ export interface ScopeOptions {
    * @default false
    */
   force?: boolean;
+  /**
+   * The strategy to use when destroying resources.
+   *
+   * @default "sequential"
+   */
+  destroyStrategy?: DestroyStrategy;
   telemetryClient?: ITelemetryClient;
   logger?: LoggerApi;
 }
@@ -127,6 +133,7 @@ export class Scope {
   public readonly local: boolean;
   public readonly watch: boolean;
   public readonly force: boolean;
+  public readonly destroyStrategy: DestroyStrategy;
   public readonly logger: LoggerApi;
   public readonly telemetryClient: ITelemetryClient;
   public readonly dataMutex: AsyncMutex;
@@ -185,7 +192,8 @@ export class Scope {
     this.local = options.local ?? this.parent?.local ?? false;
     this.watch = options.watch ?? this.parent?.watch ?? false;
     this.force = options.force ?? this.parent?.force ?? false;
-
+    this.destroyStrategy =
+      options.destroyStrategy ?? this.parent?.destroyStrategy ?? "sequential";
     if (this.local) {
       this.logger.warnOnce(
         "Development mode is in beta. Please report any issues to https://github.com/sam-goodwin/alchemy/issues.",
@@ -322,6 +330,7 @@ export class Scope {
                 [ResourceKind]: "alchemy::Scope",
                 [ResourceScope]: this,
                 [ResourceSeq]: this.seq(),
+                [DestroyStrategy]: this.destroyStrategy,
               },
               props: {},
             }
@@ -433,7 +442,7 @@ export class Scope {
       );
       await destroyAll(orphans, {
         quiet: this.quiet,
-        strategy: "sequential",
+        strategy: this.destroyStrategy,
         force: shouldForce,
       });
       this.rootTelemetryClient?.record({

package/src/test/options.ts

@@ -1,3 +1,4 @@
+import type { DestroyStrategy } from "../destroy.ts";
 import type { StateStoreType } from "../state.ts";
 
 /**
@@ -31,4 +32,11 @@ export interface TestOptions {
    * Prefix to use for the scope to isolate tests and environments.
    */
   prefix?: string;
+
+  /**
+   * The strategy to use when destroying resources.
+   *
+   * @default "sequential"
+   */
+  destroyStrategy?: DestroyStrategy;
 }

package/src/util/safe-fetch.ts

@@ -15,13 +15,10 @@ export async function safeFetch(
         dispatcher: await dispatcher(),
       } as RequestInit);
     } catch (err: any) {
+      console.log("err", err);
       latestErr = err;
       const shouldRetry =
-        err?.code === "UND_ERR_SOCKET" ||
-        err?.code === "ECONNRESET" ||
-        err?.code === "UND_ERR_CONNECT_TIMEOUT" ||
-        err?.code === "EPIPE" ||
-        err?.name === "FetchError";
+        isTransientNetworkError(err) || isTransientNetworkError(err.cause);
 
       if (!shouldRetry || attempt === retries) {
         throw err;
@@ -34,6 +31,16 @@ export async function safeFetch(
   throw latestErr;
 }
 
+function isTransientNetworkError(err: any) {
+  return (
+    err?.code === "UND_ERR_SOCKET" ||
+    err?.code === "ECONNRESET" ||
+    err?.code === "UND_ERR_CONNECT_TIMEOUT" ||
+    err?.code === "EPIPE" ||
+    err?.name === "FetchError"
+  );
+}
+
 let agent:
   | {
       value: Agent | undefined;