alchemy 0.45.5 → 0.46.0

package/src/cloudflare/worker-metadata.ts

@@ -1,6 +1,7 @@
 import { assertNever } from "../util/assert-never.ts";
 import { logger } from "../util/logger.ts";
 import { memoize } from "../util/memoize.ts";
+import { extractCloudflareResult } from "./api-response.ts";
 import type { CloudflareApi } from "./api.ts";
 import {
   Self,
@@ -200,7 +201,7 @@ export interface WorkerMetadata {
 
 export async function prepareWorkerMetadata(
   api: CloudflareApi,
-  props: WorkerProps & {
+  props: Omit<WorkerProps, "entrypoint"> & {
     compatibilityDate: string;
     compatibilityFlags: string[];
     workerName: string;
@@ -210,6 +211,7 @@ export async function prepareWorkerMetadata(
       keepAssets?: boolean;
       assetConfig?: AssetsConfig;
     };
+    tags?: string[];
     unstable_cacheWorkerSettings?: boolean;
   },
 ): Promise<WorkerMetadata> {
@@ -226,7 +228,7 @@ export async function prepareWorkerMetadata(
   // we use Cloudflare Worker tags to store a mapping between Alchemy's stable identifier and the binding name
   // e.g.
   // {
-  //   BINDING_NAME: new DurableObjectNamespace("stable-id")
+  //   BINDING_NAME: DurableObjectNamespace("stable-id")
   // }
   // will be stored as alchemy:do:stable-id:BINDING_NAME
   // TODO(sam): should we base64 encode to ensure no `:` collision risk?
@@ -323,6 +325,7 @@ export async function prepareWorkerMetadata(
       ),
       // encode the migraiton tag if there is one so we can avoid the failed PutWorker after adoption
       ...(newMigrationTag ? [`alchemy:migration-tag:${newMigrationTag}`] : []),
+      ...(props.tags ?? []),
     ],
     migrations: {
       old_tag: oldMigrationTag,
@@ -640,6 +643,7 @@ interface WorkerSettings {
   compatibility_date: string;
   compatibility_flags: string[];
   migrations: SingleStepMigration | MultiStepMigration;
+  tags: string[];
   [key: string]: any;
 }
 
@@ -648,51 +652,22 @@ const getWorkerSettingsWithCache = memoize(
   (api, workerName) => `${api.accountId}:${workerName}`,
 );
 
-async function getWorkerSettings(
+export async function getWorkerSettings(
   api: CloudflareApi,
   workerName: string,
 ): Promise<WorkerSettings | undefined> {
   // Fetch the bindings for a worker by calling the Cloudflare API endpoint:
   // GET /accounts/:account_id/workers/scripts/:script_name/bindings
   // See: https://developers.cloudflare.com/api/resources/workers/subresources/scripts/subresources/script_and_version_settings/methods/get/
-  const response = await api.get(
-    `/accounts/${api.accountId}/workers/scripts/${workerName}/settings`,
-  );
-  if (response.status === 404) {
-    return undefined;
-  }
-  if (!response.ok) {
-    throw new Error(
-      `Error getting worker bindings: ${response.status} ${response.statusText}`,
-    );
-  }
-  // The result is an object with a "result" property containing the bindings array
-  const { result, success, errors } = (await response.json()) as {
-    result: {
-      bindings: WorkerBindingSpec[];
-      compatibility_date: string;
-      compatibility_flags: string[];
-      migrations: SingleStepMigration | MultiStepMigration;
-      [key: string]: any;
-    };
-    success: boolean;
-    errors: Array<{
-      code: number;
-      message: string;
-      documentation_url: string;
-      [key: string]: any;
-    }>;
-    messages: Array<{
-      code: number;
-      message: string;
-      documentation_url: string;
-      [key: string]: any;
-    }>;
-  };
-  if (!success) {
-    throw new Error(
-      `Error getting worker bindings: ${response.status} ${response.statusText}\nErrors:\n${errors.map((e) => `- [${e.code}] ${e.message} (${e.documentation_url})`).join("\n")}`,
-    );
-  }
-  return result;
+  return await extractCloudflareResult<WorkerSettings>(
+    `get worker settings for ${workerName}`,
+    api.get(
+      `/accounts/${api.accountId}/workers/scripts/${workerName}/settings`,
+    ),
+  ).catch((error) => {
+    if (error.status === 404) {
+      return undefined;
+    }
+    throw error;
+  });
 }

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,
@@ -1471,7 +1518,7 @@ async function provisionContainers(
       }
       return ContainerApplication(container.id, {
         image: container.image,
-        name: container.id,
+        name: container.name,
         instanceType: container.instanceType,
         observability: container.observability,
         durableObjects: {
@@ -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 };
   }
 
   /**