alchemy 0.45.6 → 0.46.0

package/src/cloudflare/worker-subdomain.ts

@@ -1,12 +1,12 @@
 import type { Context } from "../context.ts";
 import { Resource } from "../resource.ts";
+import { memoize } from "../util/memoize.ts";
+import { extractCloudflareResult } from "./api-response.ts";
 import {
   createCloudflareApi,
   type CloudflareApi,
   type CloudflareApiOptions,
 } from "./api.ts";
-import type { CloudflareApiResponse } from "./types.ts";
-import { getAccountSubdomain } from "./worker/shared.ts";
 
 interface WorkerSubdomainProps extends CloudflareApiOptions {
   /**
@@ -49,16 +49,7 @@ export const WorkerSubdomain = Resource(
       }
       return this.destroy();
     }
-    await wrapFetch<SubdomainResponse>(
-      `enable subdomain for "${props.scriptName}"`,
-      api.post(
-        `/accounts/${api.accountId}/workers/scripts/${props.scriptName}/subdomain`,
-        { enabled: true, previews_enabled: true },
-        {
-          headers: { "Content-Type": "application/json" },
-        },
-      ),
-    );
+    await enableWorkerSubdomain(api, props.scriptName);
     const subdomain = await getAccountSubdomain(api);
     const base = `${subdomain}.workers.dev`;
     let url: string;
@@ -77,7 +68,7 @@ export async function disableWorkerSubdomain(
   api: CloudflareApi,
   scriptName: string,
 ) {
-  await wrapFetch<SubdomainResponse>(
+  await extractCloudflareResult<SubdomainResponse>(
     `disable subdomain for "${scriptName}"`,
     api.post(
       `/accounts/${api.accountId}/workers/scripts/${scriptName}/subdomain`,
@@ -91,33 +82,48 @@ export async function disableWorkerSubdomain(
   });
 }
 
+export async function enableWorkerSubdomain(
+  api: CloudflareApi,
+  scriptName: string,
+) {
+  await extractCloudflareResult<SubdomainResponse>(
+    `enable subdomain for "${scriptName}"`,
+    api.post(
+      `/accounts/${api.accountId}/workers/scripts/${scriptName}/subdomain`,
+      { enabled: true, previews_enabled: true },
+    ),
+  );
+}
+
+export async function getWorkerSubdomain(
+  api: CloudflareApi,
+  scriptName: string,
+) {
+  return await extractCloudflareResult<SubdomainResponse>(
+    `get subdomain for "${scriptName}"`,
+    api.get(
+      `/accounts/${api.accountId}/workers/scripts/${scriptName}/subdomain`,
+    ),
+  ).catch((error): SubdomainResponse => {
+    if (error.status === 404) {
+      return { enabled: false, previews_enabled: false };
+    }
+    throw error;
+  });
+}
+
 interface SubdomainResponse {
   enabled: boolean;
   previews_enabled: boolean;
 }
 
-async function wrapFetch<T>(
-  label: string,
-  promise: Promise<Response>,
-): Promise<T> {
-  const response = await promise.catch(() => {
-    throw new Error(`Failed to ${label}: Failed to fetch`);
-  });
-  const json = (await response.json().catch(() => {
-    throw new Error(
-      `Failed to ${label} (${response.status}): The API returned an invalid response`,
+export const getAccountSubdomain = memoize(
+  async (api: CloudflareApi) => {
+    const result = await extractCloudflareResult<{ subdomain: string }>(
+      `get subdomain for account ${api.accountId}`,
+      api.get(`/accounts/${api.accountId}/workers/subdomain`),
     );
-  })) as CloudflareApiResponse<T>;
-  if (json.success) {
-    return json.result;
-  } else {
-    const error = new Error(
-      `Failed to ${label} (${response.status}): ${json.errors.map((e) => `${e.code}: ${e.message}`).join(", ")}`,
-    );
-    Error.captureStackTrace(error, wrapFetch);
-    Object.assign(error, {
-      status: response.status,
-    });
-    throw error;
-  }
-}
+    return result.subdomain;
+  },
+  (api) => api.accountId,
+);

package/src/cloudflare/{worker/tail.ts → worker-tail.ts}

@@ -1,8 +1,8 @@
 import kleur from "kleur";
 import { WebSocket } from "ws";
-import { logger } from "../../util/logger.ts";
-import type { CloudflareApi } from "../api.ts";
-import type { CloudflareApiResponse } from "../types.ts";
+import { logger } from "../util/logger.ts";
+import type { CloudflareApiResponse } from "./api-response.ts";
+import type { CloudflareApi } from "./api.ts";
 
 export const createTail = async (
   api: CloudflareApi,
@@ -47,7 +47,12 @@ class TailClient {
     }
     const res = await this.api.post(
       `/accounts/${this.api.accountId}/workers/scripts/${this.scriptName}/tails`,
-      {},
+      { filters: [] },
+      {
+        headers: {
+          "Content-Type": "application/json",
+        },
+      },
     );
     const json = (await res.json()) as CloudflareApiResponse<Tail>;
     if (!json.success) {
@@ -72,11 +77,7 @@ class TailClient {
       throw new Error(`Failed to connect to tail for ${this.scriptName}`);
     }
     const tail = await this.create();
-    const ws = new WebSocket(tail.url, {
-      headers: {
-        "Sec-WebSocket-Protocol": "trace-v1",
-      },
-    });
+    const ws = new WebSocket(tail.url, "trace-v1");
     ws.on("open", () => {
       this.ping(ws);
       if (DEBUG) {
@@ -92,7 +93,9 @@ class TailClient {
         return;
       }
       logger.log(`reconnecting to tail for "${this.scriptName}"`);
-      this.connect(attempt + 1);
+      setTimeout(() => {
+        this.connect(attempt + 1);
+      }, 1000);
     });
     ws.on("error", (event) => {
       logger.error(`error on tail for "${this.scriptName}": ${event}`);

package/src/cloudflare/worker.ts

@@ -48,6 +48,10 @@ import {
   normalizeWorkerBundle,
 } from "./bundle/index.ts";
 import { wrap } from "./bundle/normalize.ts";
+import {
+  type CompatibilityPreset,
+  unionCompatibilityFlags,
+} from "./compatibility-presets.ts";
 import { type Container, ContainerApplication } from "./container.ts";
 import { CustomDomain } from "./custom-domain.ts";
 import { isD1Database } from "./d1-database.ts";
@@ -81,7 +85,7 @@ import {
 } from "./worker-metadata.ts";
 import { WorkerStub, isWorkerStub } from "./worker-stub.ts";
 import { WorkerSubdomain, disableWorkerSubdomain } from "./worker-subdomain.ts";
-import { createTail } from "./worker/tail.ts";
+import { createTail } from "./worker-tail.ts";
 import { Workflow, isWorkflow, upsertWorkflow } from "./workflow.ts";
 
 /**
@@ -215,6 +219,15 @@ export interface BaseWorkerProps<
    */
   compatibilityFlags?: string[];
 
+  /**
+   * Compatibility preset to automatically include common compatibility flags
+   *
+   * - "node": Includes nodejs_compat flag for Node.js compatibility
+   *
+   * @default undefined (no preset)
+   */
+  compatibility?: CompatibilityPreset;
+
   /**
    * Configuration for static assets
    */
@@ -618,8 +631,8 @@ export function WorkerRef<
  * @example
  * // Create a real-time chat worker using Durable Objects
  * // for state management:
- * const chatRooms = new DurableObjectNamespace("chat-rooms");
- * const userStore = new DurableObjectNamespace("user-store");
+ * const chatRooms = DurableObjectNamespace("chat-rooms");
+ * const userStore = DurableObjectNamespace("user-store");
  *
  * const chat = await Worker("chat", {
  *   name: "chat-worker",
@@ -693,7 +706,7 @@ export function WorkerRef<
  *   entrypoint: "./src/data.ts",
  *   bindings: {
  *     // Bind to its own durable object
- *     STORAGE: new DurableObjectNamespace("storage", {
+ *     STORAGE: DurableObjectNamespace("storage", {
  *       className: "DataStorage"
  *     })
  *   }
@@ -834,7 +847,13 @@ export function Worker<const B extends Bindings>(
         ...(props as any),
         url: true,
         compatibilityFlags: Array.from(
-          new Set(["nodejs_compat", ...(props.compatibilityFlags ?? [])]),
+          new Set([
+            "nodejs_compat",
+            ...unionCompatibilityFlags(
+              props.compatibility,
+              props.compatibilityFlags,
+            ),
+          ]),
         ),
         entrypoint: meta!.filename,
         name: workerName,
@@ -987,7 +1006,10 @@ export const _Worker = Resource(
     const workerName = props.name ?? id;
     const compatibilityDate =
       props.compatibilityDate ?? DEFAULT_COMPATIBILITY_DATE;
-    const compatibilityFlags = props.compatibilityFlags ?? [];
+    const compatibilityFlags = unionCompatibilityFlags(
+      props.compatibility,
+      props.compatibilityFlags,
+    );
     const dispatchNamespace =
       typeof props.namespace === "string"
         ? props.namespace
@@ -1085,6 +1107,26 @@ export const _Worker = Resource(
       throw error;
     }
 
+    if (this.phase === "update") {
+      const oldName = this.output.name ?? this.output.id;
+      const newName = workerName;
+
+      if (oldName !== newName) {
+        if (dispatchNamespace) {
+          await this.replace(true);
+        } else {
+          const renameResponse = await api.patch(
+            `/accounts/${api.accountId}/workers/services/${oldName}`,
+            { id: newName },
+          );
+
+          if (!renameResponse.ok) {
+            await handleApiError(renameResponse, "rename", "worker", oldName);
+          }
+        }
+      }
+    }
+
     let assetsBinding: Assets | undefined;
     const workflowsBindings: Workflow[] = [];
     const containersBindings: Container[] = [];
@@ -1219,8 +1261,13 @@ export const _Worker = Resource(
         }),
       );
       putWorkerResult = await promise.value;
-      const tail = await createTail(api, id, workerName);
-      cleanups.push(() => tail.close());
+      await createTail(api, id, workerName)
+        .then((tail) => {
+          cleanups.push(() => tail.close());
+        })
+        .catch((error) => {
+          logger.error(`Failed to create tail for ${workerName}`, error);
+        });
     } else {
       putWorkerResult = await putWorkerWithAssets(props, await bundle.create());
     }
@@ -1424,13 +1471,13 @@ const normalizeExportBindings = (
     Object.entries(bindings).map(([bindingName, binding]) => [
       bindingName,
       isDurableObjectNamespace(binding) && binding.scriptName === undefined
-        ? new DurableObjectNamespace(binding.id, {
+        ? DurableObjectNamespace(binding.id, {
             ...binding,
             // re-export this binding mapping to the host worker (this worker)
             scriptName,
           })
         : isWorkflow(binding) && binding.scriptName === undefined
-          ? new Workflow(binding.id, {
+          ? Workflow(binding.id, {
               ...binding,
               // re-export this binding mapping to the host worker (this worker)
               scriptName,
@@ -1824,21 +1871,20 @@ function createDevCommand(props: {
   }
 }
 
-type PutWorkerOptions = WorkerProps & {
+type PutWorkerOptions = Omit<WorkerProps, "entrypoint"> & {
   dispatchNamespace?: string;
   migrationTag?: string;
   workerName: string;
   scriptBundle: WorkerBundle;
-  version: string | undefined;
+  version?: string;
   compatibilityDate: string;
   compatibilityFlags: string[];
-  assetUploadResult:
-    | {
-        completionToken?: string;
-        keepAssets?: boolean;
-        assetConfig?: AssetsConfig;
-      }
-    | undefined;
+  assetUploadResult?: {
+    completionToken?: string;
+    keepAssets?: boolean;
+    assetConfig?: AssetsConfig;
+  };
+  tags?: string[];
   unstable_cacheWorkerSettings?: boolean;
 };
 

package/src/cloudflare/workflow.ts

@@ -34,31 +34,50 @@ export interface WorkflowProps {
   };
 }
 
-export function isWorkflow(binding: Binding): binding is Workflow {
-  return typeof binding === "object" && binding.type === "workflow";
-}
-
-export class Workflow<PARAMS = unknown> {
-  public readonly type = "workflow";
+export type Workflow<PARAMS = unknown> = {
+  type: "workflow";
   /**
    * Phantom property to preserve workflow params at the type level.
-   *
    * No value exists.
    */
-  public readonly _PARAMS: PARAMS = undefined!;
+  _PARAMS: PARAMS;
+  id: string;
+  workflowName: string;
+  className: string;
+  scriptName?: string;
+};
 
-  public readonly workflowName: string;
-  public readonly className: string;
-  public readonly scriptName?: string;
+export function isWorkflow(binding: Binding): binding is Workflow {
+  return typeof binding === "object" && binding.type === "workflow";
+}
 
-  constructor(
-    public readonly id: string,
-    props: WorkflowProps = {},
-  ) {
-    this.workflowName = props.workflowName ?? props.className ?? id;
-    this.className = props.className ?? this.workflowName;
-    this.scriptName = props.scriptName;
-  }
+/**
+ * Creates a workflow binding for orchestrating and automating tasks.
+ *
+ * @example
+ * ```ts
+ * // Create a basic workflow
+ * const workflow = Workflow("my-workflow", {
+ *   workflowName: "my-workflow",
+ *   className: "MyWorkflow"
+ * });
+ * ```
+ */
+export function Workflow<PARAMS = unknown>(
+  id: string,
+  props: WorkflowProps = {},
+): Workflow<PARAMS> {
+  const workflowName = props.workflowName ?? props.className ?? id;
+  const className = props.className ?? workflowName;
+
+  return {
+    type: "workflow",
+    _PARAMS: undefined!,
+    id,
+    workflowName,
+    className,
+    scriptName: props.scriptName,
+  };
 }
 
 export interface WorkflowMetadata {

package/src/context.ts

@@ -57,7 +57,7 @@ export interface BaseContext<Out extends Resource> {
    * Indicate that this resource is being replaced.
    * This will cause the resource to be deleted at the end of the stack's CREATE phase.
    */
-  replace(): never;
+  replace(force?: boolean): Promise<never>;
   /**
    * Terminate the resource lifecycle handler and destroy the resource.
    *
@@ -102,7 +102,7 @@ export function context<
   seq: number;
   props: Props;
   state: State<Kind, Props, Out>;
-  replace: () => never;
+  replace: (force?: boolean) => Promise<never>;
   isReplacement?: boolean;
 }): Context<Out> {
   type InternalSymbols =

package/src/docker/api.ts

@@ -1,8 +1,8 @@
+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 { exec } from "../os/exec.ts";
 
 /**
  * Options for Docker API requests
@@ -66,14 +66,39 @@ export class DockerApi {
       ? { ...process.env, DOCKER_CONFIG: this.configDir }
       : process.env;
 
-    const command = `${this.dockerPath} ${args.join(" ")}`;
-    const result = (await exec(command, {
-      captureOutput: true,
-      shell: true,
-      env,
-    })) as { stdout: string; stderr: string };
+    // Buffers to capture output
+    let stdout = "";
+    let stderr = "";
 
-    return result;
+    // Create the subprocess
+    const subprocess = execa(this.dockerPath, args, {
+      env: env,
+      // Don't buffer - we'll handle streams manually
+      buffer: false,
+      encoding: "utf8",
+    });
+
+    // Stream stdout in real-time
+    subprocess.stdout?.on("data", (chunk: string) => {
+      process.stdout.write(chunk);
+      stdout += chunk;
+    });
+
+    // Stream stderr in real-time
+    subprocess.stderr?.on("data", (chunk: string) => {
+      process.stderr.write(chunk);
+      stderr += chunk;
+    });
+
+    // Wait for the process to complete
+    try {
+      await subprocess;
+    } catch (error: any) {
+      // Process failed, but we still have the output
+      throw new Error(stderr || error.message || "Command failed");
+    }
+
+    return { stdout, stderr };
   }
 
   /**

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

@@ -1,149 +1,6 @@
-import fs from "node:fs";
-import path from "node:path";
-import { ResourceScope } from "../resource.ts";
-import type { Scope } from "../scope.ts";
-import { deserialize, serialize } from "../serde.ts";
-import type { State, StateStore } from "../state.ts";
-import { ignore } from "../util/ignore.ts";
+import * as state from "../state/file-system-state-store.ts";
 
-const stateRootDir = path.join(process.cwd(), ".alchemy");
-const ALCHEMY_SEPERATOR_CHAR = process.platform === "win32" ? "-" : ":";
-
-export class FileSystemStateStore implements StateStore {
-  public readonly dir: string;
-  private initialized = false;
-  constructor(
-    public readonly scope: Scope,
-    options?: {
-      rootDir?: string;
-    },
-  ) {
-    this.dir = path.join(options?.rootDir ?? stateRootDir, ...scope.chain);
-  }
-
-  async init(): Promise<void> {
-    if (this.initialized) {
-      return;
-    }
-    this.initialized = true;
-    await fs.promises.mkdir(this.dir, { recursive: true });
-  }
-
-  async deinit(): Promise<void> {
-    await ignore("ENOENT", async () => {
-      const entries = await fs.promises.readdir(this.dir, {
-        withFileTypes: true,
-      });
-      const files = entries.filter((entry) => entry.isFile());
-      if (files.length > 0) {
-        throw new Error(
-          `Cannot deinit: directory "${this.dir}" contains files and cannot be deleted.`,
-        );
-      }
-      // Only folders (or empty), delete recursively
-      await fs.promises.rm(this.dir, { recursive: true, force: true });
-    });
-  }
-
-  async count(): Promise<number> {
-    return Object.keys(await this.list()).length;
-  }
-
-  async list(): Promise<string[]> {
-    try {
-      const files = await fs.promises.readdir(this.dir, {
-        withFileTypes: true,
-      });
-      return files
-        .filter((dirent) => dirent.isFile() && dirent.name.endsWith(".json"))
-        .map((dirent) => dirent.name.replace(/\.json$/, ""))
-        .map((key) => key.replaceAll(":", "/"));
-    } catch (error: any) {
-      if (error.code === "ENOENT") {
-        return [];
-      }
-      throw error;
-    }
-  }
-
-  async get(key: string): Promise<State | undefined> {
-    try {
-      const content = await fs.promises.readFile(this.getPath(key), "utf8");
-      const state = (await deserialize(
-        this.scope,
-        JSON.parse(content),
-      )) as State;
-      if (state.output === undefined) {
-        state.output = {} as any;
-      }
-      state.output[ResourceScope] = this.scope;
-      return state;
-    } catch (error: any) {
-      if (error.code === "ENOENT") {
-        return undefined;
-      }
-      throw error;
-    }
-  }
-
-  async set(key: string, value: State): Promise<void> {
-    await this.init();
-    const file = this.getPath(key);
-    await fs.promises.mkdir(path.dirname(file), { recursive: true });
-    await fs.promises.writeFile(
-      file,
-      JSON.stringify(await serialize(this.scope, value), null, 2),
-    );
-  }
-
-  async delete(key: string): Promise<void> {
-    try {
-      return await fs.promises.unlink(this.getPath(key));
-    } catch (error: any) {
-      if (error.code === "ENOENT") {
-        return;
-      }
-      throw error;
-    }
-  }
-
-  async all(): Promise<Record<string, State>> {
-    return this.getBatch(await this.list());
-  }
-
-  async getBatch(ids: string[]): Promise<Record<string, State>> {
-    return Object.fromEntries(
-      (
-        await Promise.all(
-          Array.from(ids).flatMap(async (id) => {
-            const s = await this.get(id);
-            if (s === undefined) {
-              return [] as const;
-            }
-            return [[id, s]] as const;
-          }),
-        )
-      ).flat(),
-    );
-  }
-
-  private getPath(key: string): string {
-    if (key.includes(":")) {
-      throw new Error(`ID cannot include colons: ${key}`);
-    }
-    if (key.includes("/")) {
-      //todo(michael): remove this next time we do a breaking change
-      //* windows doesn't support ":" in file paths, but we already use ":"
-      //* so now we use both to prevent breaking changes
-      key = key.replaceAll("/", ALCHEMY_SEPERATOR_CHAR);
-    }
-    //todo(michael): remove this next time we do a breaking change
-    //* windows doesn't support "*" in file paths, but we already use "*"
-    //* when making cloudflare routes containing "*"
-    //* so now we use "+" on windows but "*" on mac/linux to prevent breaking changes
-    if (process.platform === "win32") {
-      key = key.replaceAll("*", "+");
-    }
-    return path.join(this.dir, `${key}.json`);
-  }
-}
+/**
+ * @deprecated Use `FileSystemStateStore` from `alchemy/state` instead.
+ */
+export const FileSystemStateStore = state.FileSystemStateStore;

package/src/fs/index.ts

@@ -1,7 +1,6 @@
 export * from "./copy-file.ts";
 export * from "./file-collection.ts";
 export * from "./file-ref.ts";
-export * from "./file-system-state-store.ts";
 export * from "./file.ts";
 export * from "./folder.ts";
 export * from "./static-astro-file.ts";

package/src/llms.cloudflare.txt

@@ -41,8 +41,9 @@ ALCHEMY_STATE_STORE=cloudflare
 
 ### Commands
 ```bash
-bun ./alchemy.run.ts           # Deploy
-bun ./alchemy.run.ts --destroy # Destroy all resources
+bun alchemy deploy            # Deploy
+bun alchemy dev               # Local development
+bun alchemy destroy           # Destroy all resources
 ```
 
 ## Workers
@@ -107,7 +108,7 @@ declare module "cloudflare:workers" {
 ### Creating Durable Object Namespace
 ```typescript
 // Use 'new' instead of 'await' for DurableObjectNamespace
-const counter = new DurableObjectNamespace("counter", {
+const counter = DurableObjectNamespace("counter", {
   className: "Counter",
   sqlite: true, // Enable SQLite storage
 });
@@ -161,7 +162,7 @@ export default {
 const sharedCounter = host.bindings.SHARED_COUNTER;
 
 // Method 2: Reference by worker script name
-const counter = new DurableObjectNamespace("counter", {
+const counter = DurableObjectNamespace("counter", {
   className: "Counter",
   scriptName: "provider-worker"
 });
@@ -353,7 +354,7 @@ describe("Worker Tests", () => {
 ## Common Issues
 
 - **Missing finalize()**: Resources won't be cleaned up properly
-- **Wrong DurableObject syntax**: Use `new DurableObjectNamespace()` not `await`
+- **Wrong DurableObject syntax**: Use `DurableObjectNamespace()` not `await`
 - **Type errors**: Set up env.d.ts file for binding types
 - **State conflicts**: Use different stages/prefixes for different environments
 - **Resource adoption**: Use `adopt: true` when migrating existing resources