alchemy 0.1.12 → 0.1.14

package/src/cloudflare/worker.ts

@@ -1,10 +1,15 @@
 import * as fs from "fs/promises";
 import { apply } from "../apply";
 import { Bundle, type BundleProps } from "../esbuild";
+import type { Resolved } from "../output";
 import { type Context, Resource } from "../resource";
-import { createCloudflareApi } from "./api";
-import type { WorkerBinding } from "./bindings";
-
+import { type CloudflareApi, createCloudflareApi } from "./api";
+import type { Bindings, WorkerBindingSpec } from "./bindings";
+import type { DurableObjectNamespace } from "./durable-object-namespace";
+import { isDurableObjectNamespace } from "./durable-object-namespace";
+import { isKVNamespace } from "./kv-namespace";
+import type { WorkerScriptMetadata } from "./worker-metadata";
+import type { SingleStepMigration } from "./worker-migration";
 /**
  * Properties for creating or updating a Worker
  */
@@ -22,17 +27,11 @@ export interface WorkerProps {
    */
   entrypoint?: string;
 
-  /**
-   * Reference to a pre-configured Bundle resource
-   * One of script, entryPoint, or bundle must be provided
-   */
-  bundle?: Bundle;
-
   /**
    * Bundle options when using entryPoint
    * Ignored if bundle is provided
    */
-  bundleOptions?: Omit<BundleProps, "entryPoint">;
+  bundle?: Omit<BundleProps, "entryPoint">;
 
   /**
    * Module format for the worker script
@@ -57,13 +56,15 @@ export interface WorkerProps {
   /**
    * Bindings to attach to the worker
    */
-  bindings?: WorkerBinding[];
+  bindings?: Bindings;
 
   /**
-   * Whether the worker should be deployed to production
-   * @default true
+   * Environment variables to attach to the worker
+   * These will be converted to plain_text bindings
    */
-  production?: boolean;
+  env?: {
+    [key: string]: string;
+  };
 
   /**
    * Whether to enable a workers.dev URL for this worker
@@ -71,12 +72,32 @@ export interface WorkerProps {
    * @default false
    */
   url?: boolean;
+
+  /**
+   * Observability configuration for the worker
+   * Controls whether worker logs are enabled
+   * @default { enabled: true }
+   */
+  observability?: {
+    /**
+     * Whether to enable worker logs
+     * @default true
+     */
+    enabled?: boolean;
+  };
+
+  /**
+   * Migrations to apply to the worker
+   */
+  migrations?: SingleStepMigration;
 }
 
 /**
  * Output returned after Worker creation/update
  */
 export interface WorkerOutput extends Omit<WorkerProps, "url"> {
+  type: "service";
+
   /**
    * The ID of the worker
    */
@@ -97,472 +118,579 @@ export interface WorkerOutput extends Omit<WorkerProps, "url"> {
    * Format: {name}.{subdomain}.workers.dev
    */
   url?: string;
+
+  /**
+   * The bindings that were created
+   */
+  bindings: Bindings;
+}
+
+export function isWorker(resource: any): resource is Resolved<Worker> {
+  return resource && typeof resource === "object" && resource.type === "worker";
 }
 
 export class Worker extends Resource(
   "cloudflare::Worker",
+  {
+    alwaysUpdate: true,
+  },
   async (ctx: Context<WorkerOutput>, props: WorkerProps) => {
     // Create Cloudflare API client with automatic account discovery
     const api = await createCloudflareApi();
 
-    // Validate that a name is provided
-    if (!props.name) {
-      throw new Error("Worker name is required - must be explicitly specified");
-    }
-
     // Use the provided name
     const workerName = props.name;
 
     // Validate input - we need either script, entryPoint, or bundle
-    if (!props.script && !props.entrypoint && !props.bundle) {
-      throw new Error("One of script, entryPoint, or bundle must be provided");
-    }
-
-    // For create operations, check if a worker with the same name already exists
-    if (ctx.event === "create") {
-      const checkExistsResponse = await api.get(
-        `/accounts/${api.accountId}/workers/scripts/${workerName}`,
-      );
-
-      if (checkExistsResponse.ok) {
-        throw new Error(
-          `Worker with name '${workerName}' already exists. Please use a unique name.`,
-        );
-      } else if (checkExistsResponse.status !== 404) {
-        // If it's neither a success nor a 404, it's an unexpected error
-        const errorData: any = await checkExistsResponse.json().catch(() => ({
-          errors: [{ message: checkExistsResponse.statusText }],
-        }));
-        throw new Error(
-          `Error checking if worker exists: ${errorData.errors?.[0]?.message || checkExistsResponse.statusText}`,
-        );
-      }
-      // If it's a 404, that means the worker doesn't exist yet, which is what we want
+    if (!props.script && !props.entrypoint) {
+      throw new Error("One of script or entryPoint must be provided");
     }
 
     if (ctx.event === "delete") {
-      // Delete worker
-      const deleteResponse = await api.delete(
-        `/accounts/${api.accountId}/workers/scripts/${workerName}`,
-      );
+      return deleteWorker(ctx, api, workerName);
+    } else if (ctx.event === "create") {
+      await assertWorkerDoesNotExist(ctx, api, workerName);
+    }
 
-      // 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,
-        );
-      }
+    const oldBindings = await ctx.get<Bindings>("bindings");
+
+    const scriptMetadata = await prepareWorkerMetadata(ctx, oldBindings, props);
+
+    // Get the script content - either from props.script, or by bundling
+    const scriptContent =
+      props.script ?? (await bundleWorkerScript(ctx, props));
+
+    // Upload the worker script
+    await putWorker(ctx, api, workerName, scriptContent, scriptMetadata);
+
+    // TODO: it is less than ideal that this can fail, resulting in state problem
+    await ctx.set("bindings", props.bindings);
+
+    // Handle routes if requested
+    await setupRoutes(api, workerName, props.routes || []);
+
+    // Handle worker URL if requested
+    const workerUrl = await configureURL(
+      ctx,
+      api,
+      workerName,
+      props.url ?? false,
+    );
+
+    // Get current timestamp
+    const now = Date.now();
+
+    // Construct the output
+    const output: WorkerOutput = {
+      type: "service",
+      id: workerName,
+      name: workerName,
+      script: scriptContent,
+      format: props.format || "esm", // Include format in the output
+      routes: props.routes || [],
+      bindings: props.bindings ?? {},
+      env: props.env,
+      observability: scriptMetadata.observability,
+      createdAt: now,
+      updatedAt: now,
+      url: workerUrl,
+    };
+
+    return output;
+  },
+) {}
 
-      // Also remove any associated routes if they exist
-      if (ctx.output?.routes && ctx.output.routes.length > 0 && api.zoneId) {
-        // First get existing routes to find their IDs
-        const routesResponse = await api.get(
-          `/zones/${api.zoneId}/workers/routes`,
+async function deleteWorker(
+  ctx: Context<WorkerOutput>,
+  api: CloudflareApi,
+  workerName: string,
+) {
+  // Delete worker
+  const deleteResponse = await api.delete(
+    `/accounts/${api.accountId}/workers/scripts/${workerName}`,
+  );
+
+  // 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,
+    );
+  }
+
+  // Also remove any associated routes if they exist
+  if (ctx.output?.routes && ctx.output.routes.length > 0 && api.zoneId) {
+    // First get existing routes to find their IDs
+    const routesResponse = await api.get(`/zones/${api.zoneId}/workers/routes`);
+
+    if (!routesResponse.ok) {
+      throw new Error(
+        `Could not fetch routes for cleanup: ${routesResponse.status} ${routesResponse.statusText}`,
+      );
+    }
+    const routesData: any = await routesResponse.json();
+    const existingRoutes = routesData.result || [];
+
+    for (const route of existingRoutes) {
+      if (ctx.output.routes.includes(route.pattern)) {
+        // Delete the route
+        const routeDeleteResponse = await api.delete(
+          `/zones/${api.zoneId}/workers/routes/${route.id}`,
         );
 
-        if (routesResponse.ok) {
-          const routesData: any = await routesResponse.json();
-          const existingRoutes = routesData.result || [];
-
-          for (const route of existingRoutes) {
-            if (ctx.output.routes.includes(route.pattern)) {
-              // Delete the route
-              const routeDeleteResponse = await api.delete(
-                `/zones/${api.zoneId}/workers/routes/${route.id}`,
-              );
-
-              if (!routeDeleteResponse.ok) {
-                console.warn(
-                  `Failed to delete route ${route.pattern}: ${routeDeleteResponse.status} ${routeDeleteResponse.statusText}`,
-                );
-              }
-            }
-          }
-        } else {
+        if (!routeDeleteResponse.ok) {
           console.warn(
-            "Could not fetch routes for cleanup:",
-            routesResponse.status,
-            routesResponse.statusText,
+            `Failed to delete route ${route.pattern}: ${routeDeleteResponse.status} ${routeDeleteResponse.statusText}`,
           );
         }
       }
+    }
+  }
+
+  // Disable the URL if it was enabled
+  if (ctx.output?.url) {
+    try {
+      await api.post(
+        `/accounts/${api.accountId}/workers/scripts/${workerName}/subdomain`,
+        JSON.stringify({ enabled: false }),
+        {
+          headers: { "Content-Type": "application/json" },
+        },
+      );
+    } catch (error) {
+      console.warn("Failed to disable worker URL during deletion:", error);
+    }
+  }
 
-      // Disable the URL if it was enabled
-      if (ctx.output?.url) {
-        try {
-          await api.post(
-            `/accounts/${api.accountId}/workers/scripts/${workerName}/subdomain`,
-            JSON.stringify({ enabled: false }),
-            {
-              headers: { "Content-Type": "application/json" },
-            },
-          );
-        } catch (error) {
-          console.warn("Failed to disable worker URL during deletion:", error);
-        }
-      }
-
-      // Return minimal output for deleted state
-      return {
-        ...props,
-        id: "",
-        createdAt: 0,
-        updatedAt: 0,
-        url: undefined,
-      };
-    } else {
-      // Get the script content - either from props.script, or by bundling
-      let scriptContent: string;
-
-      if (props.script) {
-        // Use the provided script
-        scriptContent = props.script;
-      } else if (props.bundle) {
-        // Use a pre-configured Bundle resource
-        const bundleOutput = await apply(props.bundle);
-        scriptContent = await fs.readFile(bundleOutput.path, "utf-8");
-      } else if (props.entrypoint) {
-        // Create and use a Bundle resource with worker-optimized configuration
-        const defaultBundleOptions: Omit<BundleProps, "entryPoint"> = {
-          format: props.format === "cjs" ? "cjs" : "esm", // Use the specified format or default to ESM
-          target: "es2020",
-          platform: "browser",
-          minify: true,
-          options: {
-            keepNames: true, // Important for Durable Object classes
-          },
-        };
-
-        // Merge with user-provided options
-        const bundleOptions = {
-          ...defaultBundleOptions,
-          ...(props.bundleOptions || {}),
-        };
-
-        // Create the bundle
-        const bundle = new Bundle("bundle", {
-          entryPoint: props.entrypoint,
-          ...bundleOptions,
-        });
+  // Return minimal output for deleted state
+  return;
+}
 
-        // Get the bundled content
-        const bundleOutput = await apply(bundle);
-        try {
-          scriptContent = await fs.readFile(bundleOutput.path, "utf-8");
-        } catch (error) {
-          console.error("Error reading bundle:", error);
-          throw new Error("Error reading bundle");
-        }
-      } else {
-        throw new Error("No script source provided"); // Shouldn't reach here due to earlier validation
-      }
-      // Prepare metadata with bindings
-      const metadata: any = {
-        bindings: [],
-      };
+async function putWorker(
+  ctx: Context<WorkerOutput>,
+  api: CloudflareApi,
+  workerName: string,
+  scriptContent: string,
+  scriptMetadata: WorkerMetadata,
+) {
+  const scriptName = scriptMetadata.main_module ?? scriptMetadata.body_part!;
+
+  // Create FormData for the upload
+  const formData = new FormData();
+
+  // Add the actual script content as a named file part
+  formData.append(
+    scriptName,
+    new Blob([scriptContent], {
+      type: scriptMetadata.main_module
+        ? "application/javascript+module"
+        : "application/javascript",
+    }),
+    scriptName,
+  );
+
+  // console.log("Script Metadata:", JSON.stringify(scriptMetadata, null, 2));
+
+  // Add metadata as JSON
+  formData.append(
+    "metadata",
+    new Blob([JSON.stringify(scriptMetadata)], {
+      type: "application/json",
+    }),
+  );
+
+  // Upload worker script with bindings
+  const uploadResponse = await api.put(
+    `/accounts/${api.accountId}/workers/scripts/${workerName}`,
+    formData,
+    {
+      headers: {
+        "Content-Type": "multipart/form-data",
+      },
+    },
+  );
+
+  // Check if the upload was successful
+  if (!uploadResponse.ok) {
+    const errorData: any = await uploadResponse
+      .json()
+      .catch(() => ({ errors: [{ message: uploadResponse.statusText }] }));
+    throw new Error(
+      `Error uploading worker script '${workerName}': ${errorData.errors?.[0]?.message || uploadResponse.statusText}`,
+    );
+  }
+
+  return formData;
+}
 
-      // Convert bindings to the format expected by the API
-      if (props.bindings && props.bindings.length > 0) {
-        for (const binding of props.bindings) {
-          const bindingData: any = {
-            name: binding.name,
-            type: binding.type,
-          };
-
-          // Map binding properties to the API format based on binding type
-          switch (binding.type) {
-            case "kv_namespace":
-              bindingData.namespace_id = (binding as any).namespace_id;
-              break;
-            case "durable_object_namespace":
-              bindingData.class_name = (binding as any).class_name;
-              if ((binding as any).namespace_id) {
-                bindingData.namespace_id = (binding as any).namespace_id;
-              }
-              if ((binding as any).script_name) {
-                bindingData.script_name = (binding as any).script_name;
-              }
-              if ((binding as any).environment) {
-                bindingData.environment = (binding as any).environment;
-              }
-              break;
-            case "secret_text":
-              bindingData.text = (binding as any).text;
-              break;
-            case "r2_bucket":
-              bindingData.bucket_name = (binding as any).bucket_name;
-              break;
-            case "analytics_engine":
-              bindingData.dataset = (binding as any).dataset;
-              break;
-            case "service":
-              bindingData.service = (binding as any).service;
-              if ((binding as any).environment) {
-                bindingData.environment = (binding as any).environment;
-              }
-              if ((binding as any).namespace) {
-                bindingData.namespace = (binding as any).namespace;
-              }
-              break;
-            case "d1":
-              bindingData.id = (binding as any).id;
-              break;
-            case "queue":
-              bindingData.queue_name = (binding as any).queue_name;
-              break;
-            case "json":
-              bindingData.json = (binding as any).json;
-              break;
-            case "hyperdrive":
-              bindingData.id = (binding as any).id;
-              break;
-            case "vectorize":
-              bindingData.index_name = (binding as any).index_name;
-              break;
-            case "dispatch_namespace":
-              bindingData.namespace = (binding as any).namespace;
-              if ((binding as any).outbound) {
-                bindingData.outbound = (binding as any).outbound;
-              }
-              break;
-            case "mtls_certificate":
-              bindingData.certificate_id = (binding as any).certificate_id;
-              break;
-            case "plain_text":
-              bindingData.text = (binding as any).text;
-              break;
-            case "wasm_module":
-              bindingData.module = (binding as any).module;
-              break;
-            case "tail_consumer":
-              bindingData.service = (binding as any).service;
-              break;
-          }
+interface WorkerMetadata {
+  bindings: WorkerBindingSpec[];
+  observability: {
+    enabled: boolean;
+  };
+  migrations?: SingleStepMigration;
+  main_module?: string;
+  body_part?: string;
+  tags?: string[];
+}
 
-          metadata.bindings.push(bindingData);
+async function prepareWorkerMetadata(
+  ctx: Context<WorkerOutput>,
+  oldBindings: Bindings | undefined,
+  props: WorkerProps,
+): Promise<WorkerMetadata> {
+  // Prepare metadata with bindings
+  const meta: WorkerMetadata = {
+    bindings: [],
+    observability: {
+      enabled: props.observability?.enabled !== false,
+    },
+    tags: [`alchemy:id:${ctx.resourceFQN}`],
+    migrations: {
+      new_classes: props.migrations?.new_classes ?? [],
+      deleted_classes: props.migrations?.deleted_classes ?? [],
+      renamed_classes: props.migrations?.renamed_classes ?? [],
+      transferred_classes: props.migrations?.transferred_classes ?? [],
+      new_sqlite_classes: props.migrations?.new_sqlite_classes ?? [],
+    },
+  };
+
+  const bindings = (props.bindings ?? {}) as Resolved<Bindings>;
+
+  // Convert bindings to the format expected by the API
+  for (const [bindingName, binding] of Object.entries(bindings)) {
+    // Create a copy of the binding to avoid modifying the original
+
+    if (isKVNamespace(binding)) {
+      meta.bindings.push({
+        type: "kv_namespace",
+        name: bindingName,
+        namespace_id: binding.id,
+      });
+    } else if (typeof binding === "string") {
+      meta.bindings.push({
+        type: "plain_text",
+        name: bindingName,
+        text: binding,
+      });
+    } else if (binding.type === "service") {
+      meta.bindings.push({
+        type: "service",
+        name: bindingName,
+        service: binding.id,
+      });
+    } else if (isDurableObjectNamespace(binding)) {
+      const stableId = binding.id;
+      const className = binding.className;
+
+      meta.bindings.push({
+        type: "durable_object_namespace",
+        name: bindingName,
+        class_name: className,
+        script_name: binding.scriptName,
+        environment: binding.environment,
+        namespace_id: binding.namespaceId,
+      });
+
+      const oldBinding: DurableObjectNamespace | undefined = Object.values(
+        oldBindings ?? {},
+      )
+        ?.filter(isDurableObjectNamespace)
+        ?.find((b) => b.id === stableId);
+
+      if (!oldBinding) {
+        if (binding.sqlite) {
+          meta.migrations!.new_sqlite_classes!.push(className);
+        } else {
+          meta.migrations!.new_classes!.push(className);
         }
+      } else if (oldBinding.className !== className) {
+        meta.migrations!.renamed_classes!.push({
+          from: oldBinding.className,
+          to: className,
+        });
       }
+    } else {
+      // @ts-expect-error - we should never reach here
+      throw new Error(`Unsupported binding type: ${binding.type}`);
+    }
+  }
+
+  // Convert env variables to plain_text bindings
+  if (props.env) {
+    for (const [key, value] of Object.entries(props.env)) {
+      meta.bindings.push({
+        name: key,
+        type: "plain_text",
+        text: value,
+      });
+    }
+  }
+
+  // Determine if we're using ESM or service worker format
+  const isEsModule = props.format !== "cjs"; // Default to ESM unless CJS is specified
+  const scriptName = isEsModule ? "worker.js" : "script";
+
+  if (isEsModule) {
+    // For ES modules format
+    meta.main_module = scriptName;
+  } else {
+    // For service worker format (CJS)
+    meta.body_part = scriptName;
+  }
+  return meta;
+}
 
-      // Create FormData for the upload
-      const formData = new FormData();
-
-      // Determine if we're using ESM or service worker format
-      const isEsModule = props.format !== "cjs"; // Default to ESM unless CJS is specified
-      const scriptName = isEsModule ? "worker.js" : "script";
-      const contentType = isEsModule
-        ? "application/javascript+module"
-        : "application/javascript";
-
-      // Prepare metadata
-      const updatedMetadata = {
-        ...metadata,
-      };
-
-      // Add Durable Object migrations if there are any DO bindings
-      const durableObjectBindings = props.bindings?.filter(
-        (binding) =>
-          binding.type === "durable_object_namespace" &&
-          // Only include self-referencing DOs (ones defined in this script)
-          (binding as any).script_name === props.name,
+async function assertWorkerDoesNotExist(
+  ctx: Context<WorkerOutput>,
+  api: CloudflareApi,
+  workerName: string,
+) {
+  const response = await api.get(
+    `/accounts/${api.accountId}/workers/scripts/${workerName}`,
+  );
+  if (response.status === 404) {
+    return true;
+  }
+  if (response.status === 200) {
+    const metadata = await getWorkerScriptMetadata(api, workerName);
+
+    if (!metadata) {
+      throw new Error(
+        `Worker exists but failed to fetch metadata: ${response.status} ${response.statusText}`,
       );
+    }
 
-      if (durableObjectBindings && durableObjectBindings.length > 0) {
-        // Add migrations metadata for Durable Objects
-        updatedMetadata.migrations = {
-          new_classes: durableObjectBindings.map(
-            (binding) => (binding as any).class_name, // Just the class name as a string
-          ),
-          deleted_classes: [],
-          renamed_classes: [],
-          // Version 2 migrations
-          new_sqlite_classes: [],
-          updated_sqlite_classes: [],
-          renamed_sqlite_classes: [],
-        };
-      }
+    if (
+      metadata.default_environment?.script.tags.includes(
+        `alchemy:id:${ctx.resourceFQN}`,
+      )
+    ) {
+      return true;
+    }
 
-      if (isEsModule) {
-        // For ES modules format
-        updatedMetadata.main_module = scriptName;
-      } else {
-        // For service worker format (CJS)
-        updatedMetadata.body_part = scriptName;
-      }
+    throw new Error(
+      `Worker with name '${workerName}' already exists. Please use a unique name.`,
+    );
+  } else {
+    throw new Error(
+      `Error checking if worker exists: ${response.status} ${response.statusText}`,
+    );
+  }
+}
 
-      // Add the actual script content as a named file part
-      formData.append(
-        scriptName,
-        new Blob([scriptContent], { type: contentType }),
-        scriptName,
-      );
+async function bundleWorkerScript(
+  ctx: Context<WorkerOutput>,
+  props: WorkerProps,
+) {
+  // Get the script content - either from props.script, or by bundling
+
+  // Create and use a Bundle resource with worker-optimized configuration
+  const defaultBundleOptions: Omit<BundleProps, "entryPoint"> = {
+    format: props.format === "cjs" ? "cjs" : "esm", // Use the specified format or default to ESM
+    target: "es2020",
+    platform: "browser",
+    minify: true,
+    options: {
+      keepNames: true, // Important for Durable Object classes
+    },
+  };
+
+  // Merge with user-provided options
+  const bundleOptions = {
+    ...defaultBundleOptions,
+    ...(props.bundle || {}),
+  };
+
+  // Create the bundle
+  const bundle = new Bundle("bundle", {
+    entryPoint: props.entrypoint!,
+    ...bundleOptions,
+    external: [...(bundleOptions.external ?? []), "cloudflare:workers"],
+  });
+
+  // Get the bundled content
+  const bundleOutput = await apply(bundle, {
+    quiet: ctx.quiet,
+  });
+  try {
+    return await fs.readFile(bundleOutput.path, "utf-8");
+  } catch (error) {
+    console.error("Error reading bundle:", error);
+    throw new Error("Error reading bundle");
+  }
+}
 
-      // Add metadata as JSON
-      formData.append(
-        "metadata",
-        new Blob([JSON.stringify(updatedMetadata)], {
-          type: "application/json",
-        }),
+async function setupRoutes(
+  api: CloudflareApi,
+  workerName: string,
+  routes: string[],
+) {
+  // Set up routes if provided
+  if (routes && routes.length > 0 && api.zoneId) {
+    // First get existing routes
+    const routesResponse = await api.get(`/zones/${api.zoneId}/workers/routes`);
+
+    if (!routesResponse.ok) {
+      throw new Error(
+        `Could not fetch routes: ${routesResponse.status} ${routesResponse.statusText}`,
       );
+    }
+    const routesData: any = await routesResponse.json();
+    const existingRoutes = routesData.result || [];
 
-      // Upload worker script with bindings
-      const uploadResponse = await api.put(
-        `/accounts/${api.accountId}/workers/scripts/${workerName}`,
-        formData,
+    // For each desired route
+    for (const pattern of routes) {
+      const existingRoute = existingRoutes.find(
+        (r: any) => r.pattern === pattern,
       );
 
-      // Check if the upload was successful
-      if (!uploadResponse.ok) {
-        const errorData: any = await uploadResponse
-          .json()
-          .catch(() => ({ errors: [{ message: uploadResponse.statusText }] }));
-        throw new Error(
-          `Error uploading worker script: ${errorData.errors?.[0]?.message || uploadResponse.statusText}`,
-        );
-      }
-
-      // Set up routes if provided
-      if (props.routes && props.routes.length > 0 && api.zoneId) {
-        // First get existing routes
-        const routesResponse = await api.get(
-          `/zones/${api.zoneId}/workers/routes`,
-        );
-
-        if (routesResponse.ok) {
-          const routesData: any = await routesResponse.json();
-          const existingRoutes = routesData.result || [];
-
-          // For each desired route
-          for (const pattern of props.routes) {
-            const existingRoute = existingRoutes.find(
-              (r: any) => r.pattern === pattern,
-            );
-
-            if (existingRoute) {
-              // Update if script name doesn't match
-              if (existingRoute.script !== workerName) {
-                const updateRouteResponse = await api.put(
-                  `/zones/${api.zoneId}/workers/routes/${existingRoute.id}`,
-                  {
-                    pattern,
-                    script: workerName,
-                  },
-                );
-
-                if (!updateRouteResponse.ok) {
-                  console.warn(
-                    `Failed to update route ${pattern}: ${updateRouteResponse.status} ${updateRouteResponse.statusText}`,
-                  );
-                }
-              }
-            } else {
-              // Create new route
-              const createRouteResponse = await api.post(
-                `/zones/${api.zoneId}/workers/routes`,
-                {
-                  pattern,
-                  script: workerName,
-                },
-              );
-
-              if (!createRouteResponse.ok) {
-                console.warn(
-                  `Failed to create route ${pattern}: ${createRouteResponse.status} ${createRouteResponse.statusText}`,
-                );
-              }
-            }
-          }
-        } else {
-          console.warn(
-            "Could not fetch routes:",
-            routesResponse.status,
-            routesResponse.statusText,
-          );
-        }
-      }
-
-      // Handle worker URL if requested
-      let workerUrl;
-      if (props.url) {
-        try {
-          // Enable the workers.dev subdomain for this worker
-          await api.post(
-            `/accounts/${api.accountId}/workers/scripts/${workerName}/subdomain`,
-            { enabled: true, previews_enabled: true },
+      if (existingRoute) {
+        // Update if script name doesn't match
+        if (existingRoute.script !== workerName) {
+          const updateRouteResponse = await api.put(
+            `/zones/${api.zoneId}/workers/routes/${existingRoute.id}`,
             {
-              headers: { "Content-Type": "application/json" },
+              pattern,
+              script: workerName,
             },
           );
 
-          // Get the account's workers.dev subdomain
-          const subdomainResponse = await api.get(
-            `/accounts/${api.accountId}/workers/subdomain`,
-          );
-
-          if (subdomainResponse.ok) {
-            const subdomainData: {
-              result: {
-                subdomain: string;
-              };
-            } = await subdomainResponse.json();
-            const subdomain = subdomainData.result?.subdomain;
-
-            if (subdomain) {
-              workerUrl = `${workerName}.${subdomain}.workers.dev`;
-
-              // Add a delay when the subdomain is first created.
-              // This is to prevent an issue where a negative cache-hit
-              // causes the subdomain to be unavailable for 30 seconds.
-              if (ctx.event === "create" || !ctx.output?.url) {
-                await new Promise((resolve) => setTimeout(resolve, 3000));
-              }
-            }
-          } else {
+          if (!updateRouteResponse.ok) {
             console.warn(
-              "Could not fetch workers.dev subdomain:",
-              subdomainResponse.status,
-              subdomainResponse.statusText,
+              `Failed to update route ${pattern}: ${updateRouteResponse.status} ${updateRouteResponse.statusText}`,
             );
           }
-        } catch (error) {
-          console.warn("Failed to enable worker URL:", error);
         }
-      } else if (props.url === false && ctx.output?.url) {
-        // Explicitly disable URL if it was previously enabled
-        try {
-          await api.post(
-            `/accounts/${api.accountId}/workers/scripts/${workerName}/subdomain`,
-            JSON.stringify({ enabled: false }),
-            {
-              headers: { "Content-Type": "application/json" },
-            },
+      } else {
+        // Create new route
+        const createRouteResponse = await api.post(
+          `/zones/${api.zoneId}/workers/routes`,
+          {
+            pattern,
+            script: workerName,
+          },
+        );
+
+        if (!createRouteResponse.ok) {
+          throw new Error(
+            `Failed to create route ${pattern}: ${createRouteResponse.status} ${createRouteResponse.statusText}`,
           );
-        } catch (error) {
-          console.warn("Failed to disable worker URL:", error);
         }
       }
+    }
+  }
+}
 
-      // Get current timestamp
-      const now = Date.now();
-
-      // Construct the output
-      const output: WorkerOutput = {
-        id: workerName,
-        name: workerName,
-        script: scriptContent,
-        format: props.format || "esm", // Include format in the output
-        routes: props.routes || [],
-        bindings: props.bindings || [],
-        production: props.production !== false,
-        createdAt: now,
-        updatedAt: now,
-        url: workerUrl,
+async function configureURL(
+  ctx: Context<WorkerOutput>,
+  api: CloudflareApi,
+  workerName: string,
+  url: boolean,
+) {
+  let workerUrl;
+  if (url) {
+    // Enable the workers.dev subdomain for this worker
+    await api.post(
+      `/accounts/${api.accountId}/workers/scripts/${workerName}/subdomain`,
+      { enabled: true, previews_enabled: true },
+      {
+        headers: { "Content-Type": "application/json" },
+      },
+    );
+
+    // Get the account's workers.dev subdomain
+    const subdomainResponse = await api.get(
+      `/accounts/${api.accountId}/workers/subdomain`,
+    );
+
+    if (!subdomainResponse.ok) {
+      throw new Error(
+        `Could not fetch workers.dev subdomain: ${subdomainResponse.status} ${subdomainResponse.statusText}`,
+      );
+    }
+    const subdomainData: {
+      result: {
+        subdomain: string;
       };
+    } = await subdomainResponse.json();
+    const subdomain = subdomainData.result?.subdomain;
 
-      return output;
+    if (subdomain) {
+      workerUrl = `https://${workerName}.${subdomain}.workers.dev`;
+
+      // Add a delay when the subdomain is first created.
+      // This is to prevent an issue where a negative cache-hit
+      // causes the subdomain to be unavailable for 30 seconds.
+      if (ctx.event === "create" || !ctx.output?.url) {
+        await new Promise((resolve) => setTimeout(resolve, 3000));
+      }
     }
-  },
-) {}
+  } else if (url === false && ctx.output?.url) {
+    // Explicitly disable URL if it was previously enabled
+    const response = await api.post(
+      `/accounts/${api.accountId}/workers/scripts/${workerName}/subdomain`,
+      JSON.stringify({ enabled: false }),
+      {
+        headers: { "Content-Type": "application/json" },
+      },
+    );
+    if (!response.ok) {
+      throw new Error(
+        `Failed to disable worker URL: ${response.status} ${response.statusText}`,
+      );
+    }
+  }
+  return workerUrl;
+}
+
+async function getWorkerScriptMetadata(
+  api: CloudflareApi,
+  workerName: string,
+): Promise<WorkerScriptMetadata | undefined> {
+  const response = await api.get(
+    `/accounts/${api.accountId}/workers/services/${workerName}`,
+  );
+  if (response.status === 404) {
+    return undefined;
+  }
+  if (!response.ok) {
+    throw new Error(
+      `Error getting worker script metadata: ${response.status} ${response.statusText}`,
+    );
+  }
+  return ((await response.json()) as any).result as WorkerScriptMetadata;
+}
+
+async function getWorkerBindings(
+  api: CloudflareApi,
+  workerName: string,
+  environment = "production",
+) {
+  const response = await api.get(
+    `/accounts/${api.accountId}/workers/services/${workerName}/environments/${environment}/bindings`,
+    {
+      headers: {
+        Authorization: `Bearer ${process.env.CLOUDFLARE_API_TOKEN}`,
+        "Content-Type": "application/json",
+      },
+    },
+  );
+
+  if (response.status === 404) {
+    return undefined;
+  }
+
+  if (!response.ok) {
+    throw new Error(
+      `Failed to fetch bindings: ${response.status} ${response.statusText}`,
+    );
+  }
+
+  const data: any = await response.json();
+
+  return data.result;
+}