alchemy 0.37.2 → 0.38.1

package/src/apply.ts

@@ -12,7 +12,7 @@ import {
   type Resource,
   type ResourceProps,
 } from "./resource.ts";
-import { Scope } from "./scope.ts";
+import { Scope, type PendingDeletions } from "./scope.ts";
 import { serialize } from "./serde.ts";
 import type { State } from "./state.ts";
 import { formatFQN } from "./util/cli.ts";
@@ -33,6 +33,8 @@ export function apply<Out extends Resource>(
   return _apply(resource, props, options);
 }
 
+export class ReplacedSignal extends Error {}
+
 async function _apply<Out extends Resource>(
   resource: PendingResource<Out>,
   props: ResourceProps | undefined,
@@ -88,6 +90,7 @@ async function _apply<Out extends Resource>(
       };
       await scope.state.set(resource[ResourceID], state);
     }
+    const oldOutput = state.output;
 
     const alwaysUpdate =
       options?.alwaysUpdate ?? provider.options?.alwaysUpdate ?? false;
@@ -162,33 +165,83 @@ async function _apply<Out extends Resource>(
       props: state.oldProps,
       state,
       replace: () => {
+        if (phase === "create") {
+          throw new Error(
+            `Resource ${resource[ResourceKind]} ${resource[ResourceFQN]} cannot be replaced in create phase.`,
+          );
+        }
         if (isReplaced) {
           logger.warn(
             `Resource ${resource[ResourceKind]} ${resource[ResourceFQN]} is already marked as REPLACE`,
           );
-          return;
         }
+
         isReplaced = true;
+        throw new ReplacedSignal();
       },
     });
 
-    const output = await alchemy.run(
-      resource[ResourceID],
-      {
-        isResource: true,
-        parent: scope,
-      },
-      async (scope) => {
-        options?.resolveInnerScope?.(scope);
-        return provider.handler.bind(ctx)(resource[ResourceID], props);
-      },
-    );
+    let output: Resource<string>;
+    try {
+      output = await alchemy.run(
+        resource[ResourceID],
+        {
+          isResource: true,
+          parent: scope,
+        },
+        async (scope) => {
+          options?.resolveInnerScope?.(scope);
+          return provider.handler.bind(ctx)(resource[ResourceID], props);
+        },
+      );
+    } catch (error) {
+      if (error instanceof ReplacedSignal) {
+        if (scope.children.get(resource[ResourceID])?.children.size! > 0) {
+          throw new Error(
+            `Resource ${resource[ResourceFQN]} has children and cannot be replaced.`,
+          );
+        }
+
+        output = await alchemy.run(
+          resource[ResourceID],
+          { isResource: true, parent: scope },
+          async () =>
+            provider.handler.bind(
+              context({
+                scope,
+                phase: "create",
+                kind: resource[ResourceKind],
+                id: resource[ResourceID],
+                fqn: resource[ResourceFQN],
+                seq: resource[ResourceSeq],
+                props: state.props,
+                state,
+                replace: () => {
+                  throw new Error(
+                    `Resource ${resource[ResourceKind]} ${resource[ResourceFQN]} cannot be replaced in create phase.`,
+                  );
+                },
+              }),
+            )(resource[ResourceID], props),
+        );
+
+        const pendingDeletions =
+          (await scope.get<PendingDeletions>("pendingDeletions")) ?? [];
+        pendingDeletions.push({
+          resource: oldOutput,
+          oldProps: state.oldProps,
+        });
+        await scope.set("pendingDeletions", pendingDeletions);
+      } else {
+        throw error;
+      }
+    }
     if (!quiet) {
       logger.task(resource[ResourceFQN], {
         prefix: phase === "create" ? "created" : "updated",
         prefixColor: "greenBright",
         resource: formatFQN(resource[ResourceFQN]),
-        message: `${phase === "create" ? "Created" : "Updated"} Resource`,
+        message: `${phase === "create" ? "Created" : isReplaced ? "Replaced" : "Updated"} Resource`,
         status: "success",
       });
     }
@@ -213,9 +266,6 @@ async function _apply<Out extends Resource>(
       props,
       // deps: [...deps],
     });
-    // if (output !== undefined) {
-    //   resource[Provide](output as Out);
-    // }
     return output as any;
   } catch (error) {
     scope.telemetryClient.record({

package/src/build-date.ts

@@ -0,0 +1,8 @@
+// This file is auto-generated during build
+// Do not edit manually
+
+/**
+ * The build date used as the default worker compatibility date.
+ * This is set to the date when the package was built.
+ */
+export const BUILD_DATE = "2025-06-23";

package/src/cloudflare/api.ts

@@ -196,7 +196,8 @@ export class CloudflareApi {
       (error) =>
         error instanceof InternalError ||
         error instanceof TooManyRequestsError ||
-        error instanceof ForbiddenError,
+        error instanceof ForbiddenError ||
+        error.code === "ECONNRESET",
       10, // Maximum 10 attempts (1 initial + 9 retries)
       1000, // Start with 1s delay, will exponentially increase
     );

package/src/cloudflare/do-state-store/internal.ts

@@ -153,7 +153,7 @@ export async function upsertStateStoreWorker(
   );
 
   // Put the worker with migration tag v1
-  const response = await api.post(
+  const response = await api.put(
     `/accounts/${api.accountId}/workers/scripts/${workerName}`,
     formData,
   );
@@ -209,7 +209,7 @@ export async function getAccountSubdomain(api: CloudflareApi) {
   const res = await api.get(`/accounts/${api.accountId}/workers/subdomain`);
   if (!res.ok) {
     throw new Error(
-      `Failed to get account subdomain: ${res.status} ${res.statusText}`,
+      `Failed to get account subdomain: ${res.status} ${res.statusText}: ${await res.text().catch(() => "unknown error")}`,
     );
   }
   const json: { result: { subdomain: string } } = await res.json();
@@ -237,5 +237,7 @@ async function bundleWorkerScript() {
   if (!result.outputFiles?.[0]) {
     throw new Error("Failed to bundle worker.ts");
   }
-  return result.outputFiles[0].text;
+  return new File([result.outputFiles[0].text], "worker.js", {
+    type: "application/javascript+module",
+  });
 }

package/src/cloudflare/do-state-store/worker.ts

@@ -63,10 +63,20 @@ export default class extends WorkerEntrypoint<Env> {
     if (!token) {
       return false;
     }
-    return timingSafeEqual(
-      new TextEncoder().encode(token),
-      new TextEncoder().encode(this.env.DOFS_TOKEN),
+
+    // Convert both to fixed-length buffers
+    const expectedBuffer = Buffer.from(this.env.DOFS_TOKEN, "utf8");
+    const providedBuffer = Buffer.alloc(expectedBuffer.length);
+
+    // Copy provided data, truncating or padding as needed
+    Buffer.from(token, "utf8").copy(
+      providedBuffer,
+      0,
+      0,
+      expectedBuffer.length,
     );
+
+    return timingSafeEqual(expectedBuffer, providedBuffer);
   }
 
   private getStub(request: Request): DurableObjectStub<DOFSStateStore> {

package/src/cloudflare/pipeline.ts

@@ -522,6 +522,7 @@ export async function createPipeline(
   api: CloudflareApi,
   pipelineName: string,
   props: PipelineProps,
+  attempt = 0,
 ): Promise<CloudflarePipelineResponse> {
   // Prepare the create payload
   const createPayload = preparePipelinePayload(api, pipelineName, props);
@@ -532,6 +533,11 @@ export async function createPipeline(
   );
 
   if (!createResponse.ok) {
+    if (createResponse.status === 404 && attempt < 3) {
+      // bucket does not exist, this might be transient, let's retry
+      await new Promise((resolve) => setTimeout(resolve, 1000 * (1 + attempt)));
+      return await createPipeline(api, pipelineName, props, attempt + 1);
+    }
     return await handleApiError(
       createResponse,
       "creating",

package/src/cloudflare/worker-stub.ts

@@ -7,6 +7,7 @@ import {
   type CloudflareApi,
   type CloudflareApiOptions,
 } from "./api.ts";
+import { configureURL } from "./worker.ts";
 
 /**
  * Properties for creating a Worker stub
@@ -19,6 +20,14 @@ export interface WorkerStubProps<
    */
   name: string;
 
+  /**
+   * Whether to enable a workers.dev URL for this worker
+   *
+   * If true, the worker will be available at {name}.{subdomain}.workers.dev
+   * @default true
+   */
+  url?: boolean;
+
   /**
    * The RPC class to use for the worker.
    *
@@ -39,6 +48,12 @@ export interface WorkerStub<
    */
   name: string;
 
+  /**
+   * The worker's URL if enabled
+   * Format: {name}.{subdomain}.workers.dev
+   */
+  url?: string;
+
   /**
    * Optional type branding for the worker's RPC entrypoint.
    *
@@ -59,12 +74,21 @@ export function isWorkerStub(resource: Resource): resource is WorkerStub {
  * exists and creates an empty one if needed.
  *
  * @example
- * // Reserve a worker name without deploying code
+ * // Reserve a worker name without deploying code, with URL enabled (default)
  * const workerStub = await WorkerStub("my-worker", {
  *   name: "my-reserved-worker"
  * });
  *
- * console.log(`Worker ${workerStub.name} exists: ${!workerStub.created}`);
+ * console.log(`Worker ${workerStub.name} is available at: ${workerStub.url}`);
+ *
+ * @example
+ * // Reserve a worker name without enabling URL
+ * const workerStub = await WorkerStub("my-worker", {
+ *   name: "my-reserved-worker",
+ *   url: false
+ * });
+ *
+ * console.log(`Worker ${workerStub.name} created without URL`);
  */
 export const WorkerStub = Resource("cloudflare::WorkerStub", async function <
   RPC extends Rpc.WorkerEntrypointBranded = Rpc.WorkerEntrypointBranded,
@@ -84,11 +108,16 @@ export const WorkerStub = Resource("cloudflare::WorkerStub", async function <
     await createEmptyWorker(api, props.name);
   }
 
+  // Configure URL if requested (defaults to true)
+  const enableUrl = props.url ?? true;
+  const workerUrl = await configureURL(this, api, props.name, enableUrl);
+
   // Return the worker stub info
   return this({
     type: "service",
     __rpc__: props.rpc as unknown as RPC,
     ...props,
+    url: workerUrl,
   }) as WorkerStub<RPC>;
 });
 

package/src/cloudflare/worker.ts

@@ -1,4 +1,5 @@
 import path from "node:path";
+import { BUILD_DATE } from "../build-date.ts";
 import type { Context } from "../context.ts";
 import type { BundleProps } from "../esbuild/bundle.ts";
 import { InnerResourceScope, Resource, ResourceKind } from "../resource.ts";
@@ -12,7 +13,6 @@ import type { type } from "../type.ts";
 import { getContentType } from "../util/content-type.ts";
 import { logger } from "../util/logger.ts";
 import { withExponentialBackoff } from "../util/retry.ts";
-import { slugify } from "../util/slugify.ts";
 import { CloudflareApiError, handleApiError } from "./api-error.ts";
 import {
   type CloudflareApi,
@@ -178,7 +178,7 @@ export interface BaseWorkerProps<
 
   /**
    * The compatibility date for the worker
-   * @default "2025-04-26"
+   * @default BUILD_DATE - automatically pinned to the package build date
    */
   compatibilityDate?: string;
 
@@ -861,7 +861,7 @@ export function Worker<const B extends Bindings>(
   });
 }
 
-export const DEFAULT_COMPATIBILITY_DATE = "2025-04-20";
+export const DEFAULT_COMPATIBILITY_DATE = BUILD_DATE;
 
 export const _Worker = Resource(
   "cloudflare::Worker",
@@ -1063,7 +1063,7 @@ export const _Worker = Resource(
         }
         // We always "adopt" when publishing versions
       } else if (!props.adopt) {
-        await assertWorkerDoesNotExist(this, api, workerName);
+        await assertWorkerDoesNotExist(api, workerName);
       }
     }
 
@@ -1429,8 +1429,7 @@ export async function checkWorkerExists(
   return response.status === 200;
 }
 
-export async function assertWorkerDoesNotExist<B extends Bindings>(
-  ctx: Context<Worker<B>>,
+export async function assertWorkerDoesNotExist(
   api: CloudflareApi,
   workerName: string,
 ) {
@@ -1449,14 +1448,6 @@ export async function assertWorkerDoesNotExist<B extends Bindings>(
       );
     }
 
-    if (
-      metadata.default_environment?.script.tags.includes(
-        `alchemy:id:${slugify(ctx.fqn)}`,
-      )
-    ) {
-      return true;
-    }
-
     throw new Error(
       `Worker with name '${workerName}' already exists. Please use a unique name.`,
     );
@@ -1467,7 +1458,7 @@ export async function assertWorkerDoesNotExist<B extends Bindings>(
 }
 
 export async function configureURL<B extends Bindings>(
-  ctx: Context<Worker<B>>,
+  ctx: Context<Worker<B>> | Context<WorkerStub>,
   api: CloudflareApi,
   workerName: string,
   url: boolean,

package/src/context.ts

@@ -53,7 +53,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(): void;
+  replace(): never;
   /**
    * Terminate the resource lifecycle handler and destroy the resource.
    *
@@ -97,7 +97,7 @@ export function context<
   seq: number;
   props: Props;
   state: State<Kind, Props, Out>;
-  replace: () => void;
+  replace: () => never;
 }): Context<Out> {
   type InternalSymbols =
     | typeof ResourceID

package/src/destroy.ts

@@ -6,10 +6,11 @@ import {
   ResourceFQN,
   ResourceID,
   ResourceKind,
+  type ResourceProps,
   ResourceScope,
   ResourceSeq,
 } from "./resource.ts";
-import { isScope, Scope } from "./scope.ts";
+import { isScope, type PendingDeletions, Scope } from "./scope.ts";
 import { formatFQN } from "./util/cli.ts";
 import { logger } from "./util/logger.ts";
 
@@ -18,6 +19,10 @@ export class DestroyedSignal extends Error {}
 export interface DestroyOptions {
   quiet?: boolean;
   strategy?: "sequential" | "parallel";
+  replace?: {
+    props?: ResourceProps | undefined;
+    output?: Resource<string>;
+  };
 }
 
 function isScopeArgs(a: any): a is [scope: Scope, options?: DestroyOptions] {
@@ -40,7 +45,8 @@ export async function destroy<Type extends string>(
     } satisfies DestroyOptions;
 
     await scope.run(async () => {
-      // destroy all active resources
+      // destroy all active and pending resources
+      await scope.destroyPendingDeletions();
       await destroyAll(Array.from(scope.resources.values()), options);
 
       // then detect orphans and destroy them
@@ -109,7 +115,7 @@ export async function destroy<Type extends string>(
       id: instance[ResourceID],
       fqn: instance[ResourceFQN],
       seq: instance[ResourceSeq],
-      props: state.props,
+      props: options?.replace?.props ?? state.props,
       state,
       replace: () => {
         throw new Error("Cannot replace a resource that is being deleted");
@@ -127,10 +133,10 @@ export async function destroy<Type extends string>(
           parent: scope,
         },
         async (scope) => {
-          nestedScope = scope;
+          nestedScope = options?.replace?.props == null ? scope : undefined;
           return await Provider.handler.bind(ctx)(
             instance[ResourceID],
-            state.props!,
+            options?.replace?.props ?? state.props!,
           );
         },
       );
@@ -146,7 +152,21 @@ export async function destroy<Type extends string>(
       await destroy(nestedScope, options);
     }
 
-    await scope.delete(instance[ResourceID]);
+    if (options?.replace == null) {
+      if (nestedScope) {
+        await destroy(nestedScope, options);
+      }
+      await scope.deleteResource(instance[ResourceID]);
+    } else {
+      let pendingDeletions =
+        await state.output[ResourceScope].get<PendingDeletions>(
+          "pendingDeletions",
+        );
+      pendingDeletions = pendingDeletions?.filter(
+        (deletion) => deletion.resource[ResourceID] !== instance[ResourceID],
+      );
+      await scope.set("pendingDeletions", pendingDeletions);
+    }
 
     if (!quiet) {
       logger.task(instance[ResourceFQN], {
@@ -165,11 +185,14 @@ export async function destroy<Type extends string>(
 
 export async function destroyAll(
   resources: Resource[],
-  options?: DestroyOptions,
+  options?: DestroyOptions & { force?: boolean },
 ) {
   if (options?.strategy !== "parallel") {
     const sorted = resources.sort((a, b) => b[ResourceSeq] - a[ResourceSeq]);
     for (const resource of sorted) {
+      if (isScope(resource)) {
+        await resource.destroyPendingDeletions();
+      }
       await destroy(resource, options);
     }
   } else {