alchemy 0.15.2 → 0.15.4

package/src/cloudflare/worker.ts

@@ -13,7 +13,7 @@ import {
   createCloudflareApi,
 } from "./api.js";
 import type { Assets } from "./assets.js";
-import type { Bindings, WorkerBindingSpec } from "./bindings.js";
+import { type Bindings, Self, type WorkerBindingSpec } from "./bindings.js";
 import type { Bound } from "./bound.js";
 import { bundleWorkerScript } from "./bundle/bundle-worker.js";
 import type { DurableObjectNamespace } from "./durable-object-namespace.js";
@@ -207,7 +207,7 @@ export interface WorkerProps<B extends Bindings = Bindings>
  */
 export interface Worker<B extends Bindings = Bindings>
   extends Resource<"cloudflare::Worker">,
-    Omit<WorkerProps<B>, "url"> {
+    Omit<WorkerProps<B>, "url" | "script"> {
   type: "service";
 
   /**
@@ -358,143 +358,182 @@ export const Worker = Resource(
     id: string,
     props: WorkerProps<B>,
   ): Promise<Worker<B>> {
-    // Create Cloudflare API client with automatic account discovery
-    const api = await createCloudflareApi(props);
-
-    // Use the provided name
-    const workerName = props.name ?? id;
-
     // Validate input - we need either script, entryPoint, or bundle
     if (!props.script && !props.entrypoint) {
       throw new Error("One of script or entryPoint must be provided");
     }
 
-    if (this.phase === "delete") {
-      await deleteWorker(this, api, workerName);
-      return this.destroy();
-    }
-    if (this.phase === "create") {
-      if (!props.adopt) {
-        await assertWorkerDoesNotExist(this, api, workerName);
-      }
-    }
+    // Create Cloudflare API client with automatic account discovery
+    const api = await createCloudflareApi(props);
+
+    // Use the provided name
+    const workerName = props.name ?? id;
 
     const oldBindings = await this.get<Bindings>("bindings");
 
     const compatibilityDate = props.compatibilityDate ?? "2025-04-20";
     const compatibilityFlags = props.compatibilityFlags ?? [];
 
-    // Get the script content - either from props.script, or by bundling
-    const scriptContent =
-      props.script ??
-      (await bundleWorkerScript({
-        ...props,
-        compatibilityDate,
-        compatibilityFlags,
-      }));
-
-    // Find any assets bindings
-    const assetsBindings: { name: string; assets: Assets }[] = [];
-    const workflowsBindings: Workflow[] = [];
-
-    if (props.bindings) {
-      for (const [bindingName, binding] of Object.entries(props.bindings)) {
-        if (typeof binding === "object") {
-          if (binding.type === "assets") {
-            assetsBindings.push({ name: bindingName, assets: binding });
-          } else if (binding.type === "workflow") {
-            workflowsBindings.push(binding);
+    const uploadWorkerScript = async (props: WorkerProps<B>) => {
+      // Get the script content - either from props.script, or by bundling
+      const scriptContent =
+        props.script ??
+        (await bundleWorkerScript({
+          ...props,
+          compatibilityDate,
+          compatibilityFlags,
+        }));
+
+      // Find any assets bindings
+      const assetsBindings: { name: string; assets: Assets }[] = [];
+      const workflowsBindings: Workflow[] = [];
+
+      if (props.bindings) {
+        for (const [bindingName, binding] of Object.entries(props.bindings)) {
+          if (typeof binding === "object") {
+            if (binding.type === "assets") {
+              assetsBindings.push({ name: bindingName, assets: binding });
+            } else if (binding.type === "workflow") {
+              workflowsBindings.push(binding);
+            }
           }
         }
       }
-    }
 
-    // Upload any assets and get completion tokens
-    let assetUploadResult: AssetUploadResult | undefined;
-    if (assetsBindings.length > 0) {
-      // We'll use the first asset binding for now
-      // In the future, we might want to support multiple asset bindings
-      const assetBinding = assetsBindings[0];
+      // Upload any assets and get completion tokens
+      let assetUploadResult: AssetUploadResult | undefined;
+      if (assetsBindings.length > 0) {
+        // We'll use the first asset binding for now
+        // In the future, we might want to support multiple asset bindings
+        const assetBinding = assetsBindings[0];
+
+        // Upload the assets and get the completion token
+        assetUploadResult = await uploadAssets(
+          api,
+          workerName,
+          assetBinding.assets,
+          props.assets,
+        );
+      }
+
+      // Prepare metadata with bindings
+      const scriptMetadata = await prepareWorkerMetadata(
+        this,
+        oldBindings,
+        {
+          ...props,
+          compatibilityDate,
+          compatibilityFlags,
+          workerName,
+        },
+        assetUploadResult,
+      );
+
+      await putWorker(api, workerName, scriptContent, scriptMetadata);
+
+      for (const workflow of workflowsBindings) {
+        await upsertWorkflow(api, {
+          workflowName: workflow.workflowName,
+          className: workflow.className,
+          scriptName: workerName,
+        });
+      }
+
+      await Promise.all(
+        props.eventSources?.map((eventSource) => {
+          if (isQueue(eventSource) || isQueueEventSource(eventSource)) {
+            const queue = isQueue(eventSource)
+              ? eventSource
+              : eventSource.queue;
+            return QueueConsumer(`${queue.id}-consumer`, {
+              queue,
+              scriptName: workerName,
+              accountId: api.accountId,
+              settings: isQueueEventSource(eventSource)
+                ? eventSource.settings
+                : undefined,
+            });
+          }
+          throw new Error(`Unsupported event source type: ${eventSource}`);
+        }) ?? [],
+      );
 
-      // Upload the assets and get the completion token
-      assetUploadResult = await uploadAssets(
+      // TODO: it is less than ideal that this can fail, resulting in state problem
+      await this.set("bindings", props.bindings);
+
+      // Handle worker URL if requested
+      const workerUrl = await configureURL(
+        this,
         api,
         workerName,
-        assetBinding.assets,
-        props.assets,
+        props.url ?? false,
       );
-    }
 
-    // Prepare metadata with bindings
-    const scriptMetadata = await prepareWorkerMetadata(
-      this,
-      oldBindings,
-      {
-        ...props,
-        compatibilityDate,
-        compatibilityFlags,
-      },
-      assetUploadResult,
-    );
+      // Get current timestamp
+      const now = Date.now();
 
-    await putWorker(api, workerName, scriptContent, scriptMetadata);
-
-    for (const workflow of workflowsBindings) {
-      await upsertWorkflow(api, {
-        workflowName: workflow.workflowName,
-        className: workflow.className,
-        scriptName: workerName,
-      });
-    }
+      // Update cron triggers
+      if (props.crons) {
+        const res = await api.put(
+          `/accounts/${api.accountId}/workers/scripts/${workerName}/schedules`,
+          props.crons.map((cron) => ({ cron })),
+        );
 
-    await Promise.all(
-      props.eventSources?.map((eventSource) => {
-        if (isQueue(eventSource) || isQueueEventSource(eventSource)) {
-          const queue = isQueue(eventSource) ? eventSource : eventSource.queue;
-          return QueueConsumer(`${queue.id}-consumer`, {
-            queue,
-            scriptName: workerName,
-            accountId: api.accountId,
-            settings: isQueueEventSource(eventSource)
-              ? eventSource.settings
-              : undefined,
-          });
+        if (!res.ok) {
+          await handleApiError(
+            res,
+            "updating cron triggers",
+            "worker",
+            workerName,
+          );
         }
-        throw new Error(`Unsupported event source type: ${eventSource}`);
-      }) ?? [],
-    );
-
-    // TODO: it is less than ideal that this can fail, resulting in state problem
-    await this.set("bindings", props.bindings);
+      }
 
-    // Handle worker URL if requested
-    const workerUrl = await configureURL(
-      this,
-      api,
-      workerName,
-      props.url ?? false,
-    );
+      return { scriptMetadata, workerUrl, now };
+    };
 
-    // Get current timestamp
-    const now = Date.now();
+    if (this.phase === "delete") {
+      if (
+        Object.values(props.bindings ?? {}).some((binding) => binding === Self)
+      ) {
+        // remove the Self bindings or else we can't remove (LOL)
+        await uploadWorkerScript({
+          ...props,
+          bindings: Object.fromEntries(
+            Object.entries(props.bindings ?? {}).filter(
+              ([_, binding]) => binding !== Self,
+            ),
+          ) as B,
+        });
+      }
 
-    // Update cron triggers
-    if (props.crons) {
-      const res = await api.put(
-        `/accounts/${api.accountId}/workers/scripts/${workerName}/schedules`,
-        props.crons.map((cron) => ({ cron })),
+      await withExponentialBackoff(
+        () =>
+          deleteWorker(this, api, {
+            ...props,
+            workerName,
+          }),
+        (err) =>
+          (err.status === 400 &&
+            err.message.includes(
+              "is still referenced by service bindings in Workers",
+            )) ||
+          err.status === 500 ||
+          err.status === 503,
+        10,
+        100,
       );
 
-      if (!res.ok) {
-        await handleApiError(
-          res,
-          "updating cron triggers",
-          "worker",
-          workerName,
-        );
+      return this.destroy();
+    }
+    if (this.phase === "create") {
+      if (!props.adopt) {
+        await assertWorkerDoesNotExist(this, api, workerName);
       }
     }
 
+    const { scriptMetadata, workerUrl, now } = await uploadWorkerScript(props);
+
     // Construct the output
     return this({
       ...props,
@@ -504,7 +543,6 @@ export const Worker = Resource(
       name: workerName,
       compatibilityDate,
       compatibilityFlags,
-      script: scriptContent,
       format: props.format || "esm", // Include format in the output
       bindings: props.bindings ?? ({} as B),
       env: props.env,
@@ -526,8 +564,9 @@ export const Worker = Resource(
 async function deleteWorker<B extends Bindings>(
   ctx: Context<Worker<B>>,
   api: CloudflareApi,
-  workerName: string,
+  props: WorkerProps<B> & { workerName: string },
 ) {
+  const workerName = props.workerName;
   // Delete any queue consumers attached to this worker first
   await deleteQueueConsumers(ctx, api, workerName);
 
@@ -538,13 +577,7 @@ async function deleteWorker<B extends Bindings>(
 
   // Check for success (2xx status code)
   if (!deleteResponse.ok && deleteResponse.status !== 404) {
-    const errorData: any = await deleteResponse
-      .json()
-      .catch(() => ({ errors: [{ message: deleteResponse.statusText }] }));
-    console.error(
-      "Error deleting worker:",
-      errorData.errors?.[0]?.message || deleteResponse.statusText,
-    );
+    await handleApiError(deleteResponse, "delete", "worker", workerName);
   }
 
   // Disable the URL if it was enabled
@@ -698,6 +731,7 @@ async function prepareWorkerMetadata<B extends Bindings>(
   props: WorkerProps & {
     compatibilityDate: string;
     compatibilityFlags: string[];
+    workerName: string;
   },
   assetUploadResult?: AssetUploadResult,
 ): Promise<WorkerMetadata> {
@@ -752,6 +786,12 @@ async function prepareWorkerMetadata<B extends Bindings>(
         name: bindingName,
         text: binding,
       });
+    } else if (binding === Self) {
+      meta.bindings.push({
+        type: "service",
+        name: bindingName,
+        service: props.workerName,
+      });
     } else if (binding.type === "d1") {
       meta.bindings.push({
         type: "d1",
@@ -807,7 +847,7 @@ async function prepareWorkerMetadata<B extends Bindings>(
         // script_name: ??,
       });
       // it's unclear whether this is needed, but it works both ways
-      configureClassMigration(binding, binding.id, binding.className);
+      // configureClassMigration(binding, binding.id, binding.className);
     } else if (binding.type === "queue") {
       meta.bindings.push({
         type: "queue",

package/src/cloudflare/wrangler.json.ts

@@ -1,7 +1,7 @@
 import type { Context } from "../context.js";
 import { StaticJsonFile } from "../fs/static-json-file.js";
 import { Resource } from "../resource.js";
-import type { Bindings } from "./bindings.js";
+import { Self, type Bindings } from "./bindings.js";
 import type { DurableObjectNamespace } from "./durable-object-namespace.js";
 import type { EventSource } from "./event-source.js";
 import { isQueueEventSource } from "./event-source.js";
@@ -340,6 +340,18 @@ function processBindings(
         spec.vars = {};
       }
       spec.vars[bindingName] = binding;
+    } else if (binding === Self) {
+      // Self(service) binding
+      services.push({
+        binding: bindingName,
+        service: bindingName,
+      });
+    } else if (binding.type === "service") {
+      // Service binding
+      services.push({
+        binding: bindingName,
+        service: binding.id,
+      });
     } else if (binding.type === "kv_namespace") {
       // KV Namespace binding
       kvNamespaces.push({
@@ -363,12 +375,6 @@ function processBindings(
         binding: bindingName,
         bucket_name: binding.name,
       });
-    } else if (binding.type === "service") {
-      // Service binding
-      services.push({
-        binding: bindingName,
-        service: binding.id,
-      });
     } else if (binding.type === "secret") {
       // Secret binding
       secrets.push(bindingName);

package/src/cloudflare/zone.ts

@@ -1,5 +1,6 @@
 import type { Context } from "../context.js";
 import { Resource } from "../resource.js";
+import { handleApiError } from "./api-error.js";
 import { createCloudflareApi, type CloudflareApiOptions } from "./api.js";
 import type {
   AlwaysUseHTTPSValue,
@@ -312,15 +313,14 @@ export const Zone = Resource(
 
     if (this.phase === "delete") {
       if (this.output?.id && props.delete !== false) {
-        // Delete zone
         const deleteResponse = await api.delete(`/zones/${this.output.id}`);
 
         if (!deleteResponse.ok && deleteResponse.status !== 404) {
-          const errorData: any = await deleteResponse.json().catch(() => ({
-            errors: [{ message: deleteResponse.statusText }],
-          }));
-          throw new Error(
-            `Error deleting zone '${props.name}': ${errorData.errors?.[0]?.message || deleteResponse.statusText}`,
+          await handleApiError(
+            deleteResponse,
+            "delete",
+            "zone",
+            this.output.id,
           );
         }
       } else {

package/src/serde.ts

@@ -22,8 +22,7 @@ export async function serialize(
 ): Promise<any> {
   if (Array.isArray(value)) {
     return Promise.all(value.map((value) => serialize(scope, value, options)));
-  }
-  if (value instanceof Secret) {
+  } else if (value instanceof Secret) {
     if (!scope.password) {
       throw new Error("Cannot serialize secret without password");
     }
@@ -33,31 +32,45 @@ export async function serialize(
           ? await encrypt(value.unencrypted, scope.password)
           : value.unencrypted,
     };
-  }
-  if (isType(value)) {
+  } else if (isType(value)) {
     return {
       "@schema": value.toJSON(),
     };
-  }
-  if (value instanceof Date) {
+  } else if (value instanceof Date) {
     return {
       "@date": value.toISOString(),
     };
-  }
-  if (value instanceof Scope) {
-    return undefined;
-  }
-  if (value && typeof value === "object") {
+  } else if (typeof value === "symbol") {
+    assertNotUniqueSymbol(value);
+    return {
+      "@symbol": value.toString(),
+    };
+  } else if (value instanceof Scope) {
+    return {
+      "@scope": null,
+    };
+  } else if (value && typeof value === "object") {
+    for (const symbol of Object.getOwnPropertySymbols(value)) {
+      assertNotUniqueSymbol(symbol);
+    }
+    for (const key of Object.keys(value)) {
+      if (parseSymbol(key)) {
+        throw new Error(
+          `Cannot serialize property '${key}' because it looks like a stringified symbol.`,
+        );
+      }
+    }
     return Object.fromEntries(
       await Promise.all(
-        Object.entries(value).map(async ([key, value]) => [
-          key,
-          await serialize(scope, value, options),
-        ]),
+        [...Object.getOwnPropertySymbols(value), ...Object.keys(value)].map(
+          async (key) => [
+            key.toString(),
+            await serialize(scope, value[key], options),
+          ],
+        ),
       ),
     );
-  }
-  if (typeof value === "function") {
+  } else if (typeof value === "function") {
     // can't serialize functions
     return undefined;
   }
@@ -76,17 +89,20 @@ export async function deserialize(scope: Scope, value: any): Promise<any> {
         throw new Error("Cannot deserialize secret without password");
       }
       return new Secret(await decryptWithKey(value["@secret"], scope.password));
-    }
-    if ("@schema" in value) {
+    } else if ("@schema" in value) {
       return value["@schema"];
-    }
-    if ("@date" in value) {
+    } else if ("@date" in value) {
       return new Date(value["@date"]);
+    } else if ("@symbol" in value) {
+      return parseSymbol(value["@symbol"]);
+    } else if ("@scope" in value) {
+      return scope;
     }
+
     return Object.fromEntries(
       await Promise.all(
         Object.entries(value).map(async ([key, value]) => [
-          key,
+          parseSymbol(key) ?? key,
           await deserialize(scope, value),
         ]),
       ),
@@ -94,3 +110,22 @@ export async function deserialize(scope: Scope, value: any): Promise<any> {
   }
   return value;
 }
+
+const symbolPattern = /^Symbol\((.*)\)$/;
+
+function parseSymbol(value: string) {
+  const match = value.match(symbolPattern);
+  if (!match) {
+    return undefined;
+  }
+  return Symbol.for(match[1]);
+}
+
+function assertNotUniqueSymbol(symbol: Symbol) {
+  if (
+    symbol.description === undefined ||
+    symbol !== Symbol.for(symbol.description)
+  ) {
+    throw new Error(`Cannot serialize unique symbol: ${symbol.description}`);
+  }
+}