alchemy 0.36.0 → 0.37.1

package/src/cloudflare/bindings.ts

@@ -48,7 +48,7 @@ export type Binding =
   | D1DatabaseResource
   | DispatchNamespaceResource
   | AnalyticsEngineDataset
-  | DurableObjectNamespace<Rpc.DurableObjectBranded | undefined>
+  | DurableObjectNamespace<any>
   | HyperdriveResource
   | Images
   | KVNamespaceResource

package/src/cloudflare/bound.ts

@@ -36,7 +36,7 @@ type BoundWorker<
 export type Bound<T extends Binding> = T extends _DurableObjectNamespace<
   infer O
 >
-  ? DurableObjectNamespace<O>
+  ? DurableObjectNamespace<O & Rpc.DurableObjectBranded>
   : T extends { type: "kv_namespace" }
     ? KVNamespace
     : T extends WorkerStub<infer RPC>

package/src/cloudflare/d1-database.ts

@@ -241,13 +241,9 @@ const D1DatabaseResource = Resource(
     const databaseName = props.name ?? id;
 
     if (this.phase === "delete") {
-      logger.log("Deleting D1 database:", databaseName);
       if (props.delete !== false) {
-        // Delete D1 database
-        logger.log("Deleting D1 database:", databaseName);
         await deleteDatabase(api, this.output?.id);
       }
-
       // Return void (a deleted database has no content)
       return this.destroy();
     }

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

@@ -3,7 +3,7 @@ import { bundle } from "../../esbuild/index.ts";
 import { withExponentialBackoff } from "../../util/retry.ts";
 import { handleApiError } from "../api-error.ts";
 import type { CloudflareApi } from "../api.ts";
-import { putWorker } from "../worker.ts";
+import type { WorkerMetadata } from "../worker-metadata.ts";
 import type { DOStateStoreAPI } from "./types.ts";
 
 interface DOStateStoreClientOptions {
@@ -116,33 +116,49 @@ export async function upsertStateStoreWorker(
     cache.set(key, TAG);
     return;
   }
-  const script = await bundleWorkerScript();
-  await putWorker(api, workerName, script, {
-    main_module: "worker.js",
-    compatibility_date: "2025-06-01",
-    compatibility_flags: ["nodejs_compat"],
-    bindings: [
-      {
-        name: "DOFS_STATE_STORE",
-        type: "durable_object_namespace",
-        class_name: "DOFSStateStore",
-      },
-      {
-        name: "DOFS_TOKEN",
-        type: "secret_text",
-        text: token,
-      },
-    ],
-    migrations: !found
-      ? {
-          new_sqlite_classes: ["DOFSStateStore"],
-        }
-      : undefined,
-    tags: [TAG],
-    observability: {
-      enabled: true,
-    },
-  });
+  const formData = new FormData();
+  formData.append("worker.js", await bundleWorkerScript());
+  formData.append(
+    "metadata",
+    new Blob([
+      JSON.stringify({
+        main_module: "worker.js",
+        compatibility_date: "2025-06-01",
+        compatibility_flags: ["nodejs_compat"],
+        bindings: [
+          {
+            name: "DOFS_STATE_STORE",
+            type: "durable_object_namespace",
+            class_name: "DOFSStateStore",
+          },
+          {
+            name: "DOFS_TOKEN",
+            type: "secret_text",
+            text: token,
+          },
+        ],
+        migrations: !found
+          ? {
+              new_sqlite_classes: ["DOFSStateStore"],
+            }
+          : undefined,
+        tags: [TAG],
+        observability: {
+          enabled: true,
+        },
+      } satisfies WorkerMetadata),
+    ]),
+  );
+
+  // Put the worker with migration tag v1
+  const response = await api.post(
+    `/accounts/${api.accountId}/workers/scripts/${workerName}`,
+    formData,
+  );
+  if (!response.ok) {
+    throw await handleApiError(response, "upload", "worker", workerName);
+  }
+
   const subdomainRes = await api.post(
     `/accounts/${api.accountId}/workers/scripts/${workerName}/subdomain`,
     { enabled: true, preview_enabled: false },
@@ -151,7 +167,7 @@ export async function upsertStateStoreWorker(
     },
   );
   if (!subdomainRes.ok) {
-    await handleApiError(
+    throw await handleApiError(
       subdomainRes,
       "creating worker subdomain",
       "worker",

package/src/cloudflare/durable-object-namespace.ts

@@ -41,9 +41,8 @@ export function isDurableObjectNamespace(
  *   environment: "production"
  * });
  */
-export class DurableObjectNamespace<
-  T extends Rpc.DurableObjectBranded | undefined = undefined,
-> implements DurableObjectNamespaceInput
+export class DurableObjectNamespace<T = any>
+  implements DurableObjectNamespaceInput
 {
   public readonly type = "durable_object_namespace" as const;
   // alias for bindingName to be consistent with other bindings

package/src/cloudflare/website.ts

@@ -115,33 +115,52 @@ export async function Website<B extends Bindings>(
       parent: Scope.current,
     },
     async () => {
+      // directory from which all relative paths are resolved
       const cwd = path.resolve(props.cwd || process.cwd());
-      const fileName =
+
+      function resolveAbsPath<S extends string | undefined>(f: S): S {
+        return (
+          f ? (path.isAbsolute(f) ? f : path.resolve(cwd, f)) : undefined
+        ) as S;
+      }
+
+      // absolute path to the wrangler.jsonc file
+      const wranglerJsonPath = resolveAbsPath(
         typeof wrangler === "boolean"
           ? "wrangler.jsonc"
           : typeof wrangler === "string"
             ? wrangler
-            : (wrangler?.path ?? "wrangler.jsonc");
-      const wranglerPath =
-        fileName && path.relative(cwd, path.join(cwd, fileName));
-      const wranglerMain =
-        typeof wrangler === "object"
-          ? (wrangler.main ?? props.main)
-          : props.main;
+            : (wrangler?.path ?? "wrangler.jsonc"),
+      );
 
-      const workerName = props.name ?? id;
+      // absolute path to the worker entrypoint
+      const mainPath = resolveAbsPath(props.main);
 
-      const assetDir =
+      // absolute path to the worker entrypoint (if different in wrangler.jsonc)
+      const wranglerMainPath = resolveAbsPath(
+        typeof wrangler === "object"
+          ? (wrangler.main ?? props.main!)
+          : props.main,
+      );
+
+      // absolute path to the assets directory
+      const assetsDirPath = resolveAbsPath(
         typeof props.assets === "string"
           ? props.assets
-          : (props.assets?.dist ?? "dist");
+          : (props.assets?.dist ?? "dist"),
+      );
+
+      const workerName = props.name ?? id;
 
       const workerProps = {
         ...props,
         compatibilityDate:
           props.compatibilityDate ?? DEFAULT_COMPATIBILITY_DATE,
         name: workerName,
-        entrypoint: props.main,
+        entrypoint: mainPath
+          ? // this path should be relative to the process.cwd() because it is used by esbuild
+            path.relative(process.cwd(), mainPath)
+          : undefined,
         assets: {
           html_handling: "auto-trailing-slash",
           not_found_handling: props.spa ? "single-page-application" : "none",
@@ -161,14 +180,18 @@ export default {
       } as WorkerProps<any> & { name: string };
 
       if (wrangler) {
+        // paths in wrangler.jsonc must be relative to it
+        const relativeToWrangler = <S extends string | undefined>(f: S): S =>
+          (f ? path.relative(path.dirname(wranglerJsonPath), f) : f) as S;
         await WranglerJson("wrangler.jsonc", {
-          path: wranglerPath,
+          path: wranglerJsonPath,
           worker: workerProps,
-          main: wranglerMain,
+          main: relativeToWrangler(wranglerMainPath),
           // hard-code the assets directory because we haven't yet included the assets binding
           assets: {
             binding: "ASSETS",
-            directory: assetDir,
+            // path must be relative to the wrangler.jsonc file
+            directory: relativeToWrangler(assetsDirPath),
           },
         });
       }
@@ -189,7 +212,8 @@ export default {
           // we don't include the Assets binding until after build to make sure the asset manifest is correct
           // we generate the wrangler.json using all the bind
           ASSETS: await Assets("assets", {
-            path: assetDir,
+            // Assets are discovered from proces.cwd(), not Website.cwd or wrangler.jsonc
+            path: path.relative(process.cwd(), assetsDirPath),
           }),
         },
       } as WorkerProps<any> & { name: string })) as Website<B>;

package/src/cloudflare/worker-metadata.ts

@@ -1,7 +1,6 @@
 import path from "node:path";
-import type { Context } from "../context.ts";
 import { logger } from "../util/logger.ts";
-import { slugify } from "../util/slugify.ts";
+import type { CloudflareApi } from "./api.ts";
 import {
   Self,
   type Bindings,
@@ -13,8 +12,11 @@ import {
   type DurableObjectNamespace,
 } from "./durable-object-namespace.ts";
 import { createAssetConfig, type AssetUploadResult } from "./worker-assets.ts";
-import type { SingleStepMigration } from "./worker-migration.ts";
-import type { AssetsConfig, Worker, WorkerProps } from "./worker.ts";
+import type {
+  MultiStepMigration,
+  SingleStepMigration,
+} from "./worker-migration.ts";
+import type { AssetsConfig, WorkerProps } from "./worker.ts";
 
 /**
  * Metadata returned by Cloudflare API for a worker script
@@ -193,17 +195,21 @@ export interface WorkerMetadata {
   }[];
 }
 
-export async function prepareWorkerMetadata<B extends Bindings>(
-  ctx: Context<Worker<B>>,
-  oldBindings: WorkerBindingSpec[] | undefined,
-  oldTags: string[] | undefined,
+export async function prepareWorkerMetadata(
+  api: CloudflareApi,
   props: WorkerProps & {
     compatibilityDate: string;
     compatibilityFlags: string[];
     workerName: string;
+    migrationTag?: string;
+    assetUploadResult?: AssetUploadResult;
   },
-  assetUploadResult?: AssetUploadResult,
 ): Promise<WorkerMetadata> {
+  const oldSettings = await getWorkerSettings(api, props.workerName);
+  const oldTags: string[] | undefined =
+    oldSettings?.default_environment?.script?.tags;
+  const oldBindings = oldSettings?.bindings;
+
   // we use Cloudflare Worker tags to store a mapping between Alchemy's stable identifier and the binding name
   // e.g.
   // {
@@ -212,7 +218,7 @@ export async function prepareWorkerMetadata<B extends Bindings>(
   // will be stored as alchemy:do:stable-id:BINDING_NAME
   // TODO(sam): should we base64 encode to ensure no `:` collision risk?
   const bindingNameToStableId = Object.fromEntries(
-    oldTags?.flatMap((tag) => {
+    oldTags?.flatMap((tag: string) => {
       // alchemy:do:{stableId}:{bindingName}
       if (tag.startsWith("alchemy:do:")) {
         const [, , stableId, bindingName] = tag.split(":");
@@ -222,6 +228,14 @@ export async function prepareWorkerMetadata<B extends Bindings>(
     }) ?? [],
   );
 
+  const oldMigrationTag = oldTags?.flatMap((tag: string) => {
+    if (tag.startsWith("alchemy:migration-tag:")) {
+      return [tag.slice("alchemy:migration-tag:".length)];
+    }
+    return [];
+  })[0];
+  const newMigrationTag = bumpMigrationTagVersion(oldMigrationTag);
+
   const deletedClasses = oldBindings?.flatMap((oldBinding) => {
     if (
       oldBinding.type === "durable_object_namespace" &&
@@ -284,7 +298,6 @@ export async function prepareWorkerMetadata<B extends Bindings>(
     },
     // TODO(sam): base64 encode instead? 0 collision risk vs readability.
     tags: [
-      `alchemy:id:${slugify(ctx.fqn)}`,
       // encode a mapping table of Durable Object stable ID -> binding name
       // we use this to reliably compute class migrations based on server-side state
       ...Object.entries(props.bindings ?? {}).flatMap(
@@ -294,19 +307,21 @@ export async function prepareWorkerMetadata<B extends Bindings>(
               [`alchemy:do:${binding.id}:${bindingName}`]
             : [],
       ),
+      // encode the migraiton tag if there is one so we can avoid the failed PutWorker after adoption
+      ...(newMigrationTag ? [`alchemy:migration-tag:${newMigrationTag}`] : []),
     ],
     migrations: {
-      new_classes: props.migrations?.new_classes ?? [],
-      deleted_classes: [
-        ...(deletedClasses ?? []),
-        ...(props.migrations?.deleted_classes ?? []),
-      ],
-      renamed_classes: props.migrations?.renamed_classes ?? [],
-      transferred_classes: props.migrations?.transferred_classes ?? [],
-      new_sqlite_classes: props.migrations?.new_sqlite_classes ?? [],
+      old_tag: oldMigrationTag,
+      new_tag: newMigrationTag,
+      new_classes: [],
+      deleted_classes: [...(deletedClasses ?? [])],
+      renamed_classes: [],
+      transferred_classes: [],
+      new_sqlite_classes: [],
     },
   };
 
+  const assetUploadResult = props.assetUploadResult;
   // If we have asset upload results, add them to the metadata
   if (assetUploadResult) {
     meta.assets = {
@@ -577,3 +592,70 @@ export async function prepareWorkerMetadata<B extends Bindings>(
   }
   return meta;
 }
+
+export function bumpMigrationTagVersion(tag?: string) {
+  if (tag) {
+    if (!tag.match(/^v\d+$/)) {
+      throw new Error(`Invalid tag format: ${tag}. Expected format: v<number>`);
+    }
+    return `v${Number.parseInt(tag.slice(1)) + 1}`;
+  }
+  return undefined;
+}
+
+interface WorkerSettings {
+  bindings: WorkerBindingSpec[];
+  compatibility_date: string;
+  compatibility_flags: string[];
+  migrations: SingleStepMigration | MultiStepMigration;
+  [key: string]: any;
+}
+
+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;
+}