alchemy 0.1.12 → 0.1.13

package/lib/cloudflare/worker.js

@@ -3,362 +3,356 @@ import { apply } from "../apply";
 import { Bundle } from "../esbuild";
 import { Resource } from "../resource";
 import { createCloudflareApi } from "./api";
-export class Worker extends Resource("cloudflare::Worker", async (ctx, props) => {
+import { isDurableObjectNamespace } from "./durable-object-namespace";
+export class Worker extends Resource("cloudflare::Worker", {
+    alwaysUpdate: true,
+}, async (ctx, props) => {
     // 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 = 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}`);
-        // Check for success (2xx status code)
-        if (!deleteResponse.ok && deleteResponse.status !== 404) {
-            const errorData = await deleteResponse
-                .json()
-                .catch(() => ({ errors: [{ message: deleteResponse.statusText }] }));
-            console.error("Error deleting worker:", errorData.errors?.[0]?.message || deleteResponse.statusText);
+        return deleteWorker(ctx, api, workerName);
+    }
+    else if (ctx.event === "create") {
+        await assertWorkerDoesNotExist(ctx, api, workerName);
+    }
+    const oldBindings = await ctx.get("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 = {
+        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;
+}) {
+}
+async function deleteWorker(ctx, api, workerName) {
+    // 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 = 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}`);
         }
-        // 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) {
-                const routesData = 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}`);
-                        }
-                    }
+        const routesData = 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 {
-                console.warn("Could not fetch routes for cleanup:", routesResponse.status, routesResponse.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);
-            }
         }
-        // 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;
-        if (props.script) {
-            // Use the provided script
-            scriptContent = props.script;
+    // 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" },
+            });
         }
-        else if (props.bundle) {
-            // Use a pre-configured Bundle resource
-            const bundleOutput = await apply(props.bundle);
-            scriptContent = await fs.readFile(bundleOutput.path, "utf-8");
+        catch (error) {
+            console.warn("Failed to disable worker URL during deletion:", error);
         }
-        else if (props.entrypoint) {
-            // Create and use a Bundle resource with worker-optimized configuration
-            const defaultBundleOptions = {
-                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;
+}
+async function putWorker(ctx, api, workerName, scriptContent, scriptMetadata) {
+    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 = await uploadResponse
+            .json()
+            .catch(() => ({ errors: [{ message: uploadResponse.statusText }] }));
+        throw new Error(`Error uploading worker script '${workerName}': ${errorData.errors?.[0]?.message || uploadResponse.statusText}`);
+    }
+    return formData;
+}
+async function prepareWorkerMetadata(ctx, oldBindings, props) {
+    // Prepare metadata with bindings
+    const meta = {
+        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 ?? [],
+        },
+    };
+    // Convert bindings to the format expected by the API
+    for (const binding of props.bindings ?? []) {
+        // Create a copy of the binding to avoid modifying the original
+        const bindingData = { ...binding };
+        if (isDurableObjectNamespace(bindingData)) {
+            const stableId = bindingData.id;
+            const className = bindingData.className;
+            meta.bindings.push({
+                type: "durable_object_namespace",
+                name: bindingData.bindingName,
+                class_name: className,
+                script_name: bindingData.scriptName,
+                environment: bindingData.environment,
+                namespace_id: bindingData.namespaceId,
             });
-            // Get the bundled content
-            const bundleOutput = await apply(bundle);
-            try {
-                scriptContent = await fs.readFile(bundleOutput.path, "utf-8");
+            const oldBinding = oldBindings
+                ?.filter(isDurableObjectNamespace)
+                ?.find((b) => b.id === stableId);
+            if (!oldBinding) {
+                if (bindingData.sqlite) {
+                    meta.migrations.new_sqlite_classes.push(className);
+                }
+                else {
+                    meta.migrations.new_classes.push(className);
+                }
             }
-            catch (error) {
-                console.error("Error reading bundle:", error);
-                throw new Error("Error reading bundle");
+            else if (oldBinding.className !== className) {
+                meta.migrations.renamed_classes.push({
+                    from: oldBinding.className,
+                    to: className,
+                });
             }
         }
         else {
-            throw new Error("No script source provided"); // Shouldn't reach here due to earlier validation
-        }
-        // Prepare metadata with bindings
-        const metadata = {
-            bindings: [],
-        };
-        // Convert bindings to the format expected by the API
-        if (props.bindings && props.bindings.length > 0) {
-            for (const binding of props.bindings) {
-                const bindingData = {
-                    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.namespace_id;
-                        break;
-                    case "durable_object_namespace":
-                        bindingData.class_name = binding.class_name;
-                        if (binding.namespace_id) {
-                            bindingData.namespace_id = binding.namespace_id;
-                        }
-                        if (binding.script_name) {
-                            bindingData.script_name = binding.script_name;
-                        }
-                        if (binding.environment) {
-                            bindingData.environment = binding.environment;
-                        }
-                        break;
-                    case "secret_text":
-                        bindingData.text = binding.text;
-                        break;
-                    case "r2_bucket":
-                        bindingData.bucket_name = binding.bucket_name;
-                        break;
-                    case "analytics_engine":
-                        bindingData.dataset = binding.dataset;
-                        break;
-                    case "service":
-                        bindingData.service = binding.service;
-                        if (binding.environment) {
-                            bindingData.environment = binding.environment;
-                        }
-                        if (binding.namespace) {
-                            bindingData.namespace = binding.namespace;
-                        }
-                        break;
-                    case "d1":
-                        bindingData.id = binding.id;
-                        break;
-                    case "queue":
-                        bindingData.queue_name = binding.queue_name;
-                        break;
-                    case "json":
-                        bindingData.json = binding.json;
-                        break;
-                    case "hyperdrive":
-                        bindingData.id = binding.id;
-                        break;
-                    case "vectorize":
-                        bindingData.index_name = binding.index_name;
-                        break;
-                    case "dispatch_namespace":
-                        bindingData.namespace = binding.namespace;
-                        if (binding.outbound) {
-                            bindingData.outbound = binding.outbound;
-                        }
-                        break;
-                    case "mtls_certificate":
-                        bindingData.certificate_id = binding.certificate_id;
-                        break;
-                    case "plain_text":
-                        bindingData.text = binding.text;
-                        break;
-                    case "wasm_module":
-                        bindingData.module = binding.module;
-                        break;
-                    case "tail_consumer":
-                        bindingData.service = binding.service;
-                        break;
-                }
-                metadata.bindings.push(bindingData);
-            }
+            // For all other binding types, use as-is
+            meta.bindings.push(bindingData);
         }
-        // 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.script_name === props.name);
-        if (durableObjectBindings && durableObjectBindings.length > 0) {
-            // Add migrations metadata for Durable Objects
-            updatedMetadata.migrations = {
-                new_classes: durableObjectBindings.map((binding) => binding.class_name),
-                deleted_classes: [],
-                renamed_classes: [],
-                // Version 2 migrations
-                new_sqlite_classes: [],
-                updated_sqlite_classes: [],
-                renamed_sqlite_classes: [],
-            };
+    }
+    // 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,
+            });
         }
-        if (isEsModule) {
-            // For ES modules format
-            updatedMetadata.main_module = scriptName;
+    }
+    // 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;
+}
+async function assertWorkerDoesNotExist(ctx, api, workerName) {
+    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}`);
         }
-        else {
-            // For service worker format (CJS)
-            updatedMetadata.body_part = scriptName;
+        if (metadata.default_environment?.script.tags.includes(`alchemy:id:${ctx.resourceFQN}`)) {
+            return true;
         }
-        // Add the actual script content as a named file part
-        formData.append(scriptName, new Blob([scriptContent], { type: contentType }), scriptName);
-        // Add metadata as JSON
-        formData.append("metadata", new Blob([JSON.stringify(updatedMetadata)], {
-            type: "application/json",
-        }));
-        // Upload worker script with bindings
-        const uploadResponse = await api.put(`/accounts/${api.accountId}/workers/scripts/${workerName}`, formData);
-        // Check if the upload was successful
-        if (!uploadResponse.ok) {
-            const errorData = await uploadResponse
-                .json()
-                .catch(() => ({ errors: [{ message: uploadResponse.statusText }] }));
-            throw new Error(`Error uploading worker script: ${errorData.errors?.[0]?.message || uploadResponse.statusText}`);
+        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}`);
+    }
+}
+async function bundleWorkerScript(ctx, props) {
+    // Get the script content - either from props.script, or by bundling
+    // Create and use a Bundle resource with worker-optimized configuration
+    const defaultBundleOptions = {
+        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");
+    }
+}
+async function setupRoutes(api, workerName, routes) {
+    // 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}`);
         }
-        // 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 = await routesResponse.json();
-                const existingRoutes = routesData.result || [];
-                // For each desired route
-                for (const pattern of props.routes) {
-                    const existingRoute = existingRoutes.find((r) => 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}`);
-                        }
+        const routesData = await routesResponse.json();
+        const existingRoutes = routesData.result || [];
+        // For each desired route
+        for (const pattern of routes) {
+            const existingRoute = existingRoutes.find((r) => 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 {
-                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 }, {
-                    headers: { "Content-Type": "application/json" },
+                // Create new route
+                const createRouteResponse = await api.post(`/zones/${api.zoneId}/workers/routes`, {
+                    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 = 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));
-                        }
-                    }
+                if (!createRouteResponse.ok) {
+                    throw new Error(`Failed to create route ${pattern}: ${createRouteResponse.status} ${createRouteResponse.statusText}`);
                 }
-                else {
-                    console.warn("Could not fetch workers.dev subdomain:", subdomainResponse.status, subdomainResponse.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" },
-                });
-            }
-            catch (error) {
-                console.warn("Failed to disable worker URL:", error);
+    }
+}
+async function configureURL(ctx, api, workerName, url) {
+    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 = await subdomainResponse.json();
+        const subdomain = subdomainData.result?.subdomain;
+        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));
             }
         }
-        // Get current timestamp
-        const now = Date.now();
-        // Construct the output
-        const output = {
-            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,
-        };
-        return output;
     }
-}) {
+    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, workerName) {
+    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()).result;
+}
+async function getWorkerBindings(api, workerName, 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 = await response.json();
+    return data.result;
 }
 //# sourceMappingURL=worker.js.map