wrangler 0.0.0-e2a26a0 → 0.0.0-e3e3243

package/src/{api/preview.ts → create-worker-preview.ts}

@@ -1,8 +1,8 @@
 import { URL } from "node:url";
 import { fetch } from "undici";
-import { fetchResult } from "../cfetch";
-import { toFormData } from "./form_data";
-import type { CfAccount, CfWorkerInit } from "./worker";
+import { fetchResult } from "./cfetch";
+import { createWorkerUploadForm } from "./create-worker-upload-form";
+import type { CfAccount, CfWorkerContext, CfWorkerInit } from "./worker";
 
 /**
  * A preview mode.
@@ -55,10 +55,13 @@ export interface CfPreviewToken {
 /**
  * Generates a preview session token.
  */
-async function sessionToken(account: CfAccount): Promise<CfPreviewToken> {
-  const { accountId, zoneId } = account;
-  const initUrl = zoneId
-    ? `/zones/${zoneId}/workers/edge-preview`
+async function sessionToken(
+  account: CfAccount,
+  ctx: CfWorkerContext
+): Promise<CfPreviewToken> {
+  const { accountId } = account;
+  const initUrl = ctx.zone
+    ? `/zones/${ctx.zone.id}/workers/edge-preview`
     : `/accounts/${accountId}/workers/subdomain/edge-preview`;
 
   const { exchange_url } = await fetchResult<{ exchange_url: string }>(initUrl);
@@ -90,21 +93,28 @@ function randomId(): string {
 /**
  * Creates a preview token.
  */
-export async function previewToken(
+async function createPreviewToken(
   account: CfAccount,
-  worker: CfWorkerInit
+  worker: CfWorkerInit,
+  ctx: CfWorkerContext
 ): Promise<CfPreviewToken> {
-  const { value, host, inspectorUrl, prewarmUrl } = await sessionToken(account);
+  const { value, host, inspectorUrl, prewarmUrl } = await sessionToken(
+    account,
+    ctx
+  );
 
-  const { accountId, zoneId } = account;
-  const scriptId = zoneId ? randomId() : worker.name || host.split(".")[0];
-  const url = `/accounts/${accountId}/workers/scripts/${scriptId}/edge-preview`;
+  const { accountId } = account;
+  const scriptId = ctx.zone ? randomId() : worker.name || host.split(".")[0];
+  const url =
+    ctx.env && !ctx.legacyEnv
+      ? `/accounts/${accountId}/workers/services/${scriptId}/environments/${ctx.env}/edge-preview`
+      : `/accounts/${accountId}/workers/scripts/${scriptId}/edge-preview`;
 
-  const mode: CfPreviewMode = zoneId
-    ? { routes: ["*/*"] }
+  const mode: CfPreviewMode = ctx.zone
+    ? { routes: ["*/*"] } // TODO: should we support routes here? how?
     : { workers_dev: true };
 
-  const formData = toFormData(worker);
+  const formData = createWorkerUploadForm(worker);
   formData.set("wrangler-session-config", JSON.stringify(mode));
 
   const { preview_token } = await fetchResult<{ preview_token: string }>(url, {
@@ -117,12 +127,40 @@ export async function previewToken(
 
   return {
     value: preview_token,
-    // TODO: verify this works with zoned workers
-    host:
-      worker.name && !zoneId
-        ? `${worker.name}.${host.split(".").slice(1).join(".")}`
-        : host,
+    host: ctx.zone
+      ? ctx.zone.host
+      : worker.name
+      ? `${
+          worker.name
+          // TODO: this should also probably have the env prefix
+          // but it doesn't appear to work yet, instead giving us the
+          // "There is nothing here yet" screen
+          // ctx.env && !ctx.legacyEnv
+          //   ? `${ctx.env}.${worker.name}`
+          //   : worker.name
+        }.${host.split(".").slice(1).join(".")}`
+      : host,
+
     inspectorUrl,
     prewarmUrl,
   };
 }
+
+/**
+ * A stub to create a Cloudflare Worker preview.
+ *
+ * @example
+ * const {value, host} = await createWorker(init, acct);
+ */
+export async function createWorkerPreview(
+  init: CfWorkerInit,
+  account: CfAccount,
+  ctx: CfWorkerContext
+): Promise<CfPreviewToken> {
+  const token = await createPreviewToken(account, init, ctx);
+  const response = await fetch(token.prewarmUrl.href, { method: "POST" });
+  if (!response.ok) {
+    // console.error("worker failed to prewarm: ", response.statusText);
+  }
+  return token;
+}

package/src/create-worker-upload-form.ts

@@ -0,0 +1,217 @@
+import { readFileSync } from "node:fs";
+import { FormData, File } from "undici";
+import type {
+  CfWorkerInit,
+  CfModuleType,
+  CfDurableObjectMigrations,
+} from "./worker.js";
+
+export function toMimeType(type: CfModuleType): string {
+  switch (type) {
+    case "esm":
+      return "application/javascript+module";
+    case "commonjs":
+      return "application/javascript";
+    case "compiled-wasm":
+      return "application/wasm";
+    case "buffer":
+      return "application/octet-stream";
+    case "text":
+      return "text/plain";
+    default:
+      throw new TypeError("Unsupported module: " + type);
+  }
+}
+
+export interface WorkerMetadata {
+  /** The name of the entry point module. Only exists when the worker is in the ES module format */
+  main_module?: string;
+  /** The name of the entry point module. Only exists when the worker is in the Service Worker format */
+  body_part?: string;
+  compatibility_date?: string;
+  compatibility_flags?: string[];
+  usage_model?: "bundled" | "unbound";
+  migrations?: CfDurableObjectMigrations;
+  bindings: (
+    | { type: "kv_namespace"; name: string; namespace_id: string }
+    | { type: "plain_text"; name: string; text: string }
+    | { type: "json"; name: string; json: unknown }
+    | { type: "wasm_module"; name: string; part: string }
+    | { type: "text_blob"; name: string; part: string }
+    | {
+        type: "durable_object_namespace";
+        name: string;
+        class_name: string;
+        script_name?: string;
+      }
+    | { type: "r2_bucket"; name: string; bucket_name: string }
+  )[];
+}
+
+/**
+ * Creates a `FormData` upload from a `CfWorkerInit`.
+ */
+export function createWorkerUploadForm(worker: CfWorkerInit): FormData {
+  const formData = new FormData();
+  const {
+    main,
+    bindings,
+    migrations,
+    usage_model,
+    compatibility_date,
+    compatibility_flags,
+  } = worker;
+
+  let { modules } = worker;
+
+  const metadataBindings: WorkerMetadata["bindings"] = [];
+
+  bindings.kv_namespaces?.forEach(({ id, binding }) => {
+    metadataBindings.push({
+      name: binding,
+      type: "kv_namespace",
+      namespace_id: id,
+    });
+  });
+
+  bindings.durable_objects?.bindings.forEach(
+    ({ name, class_name, script_name }) => {
+      metadataBindings.push({
+        name,
+        type: "durable_object_namespace",
+        class_name: class_name,
+        ...(script_name && { script_name }),
+      });
+    }
+  );
+
+  bindings.r2_buckets?.forEach(({ binding, bucket_name }) => {
+    metadataBindings.push({
+      name: binding,
+      type: "r2_bucket",
+      bucket_name,
+    });
+  });
+
+  Object.entries(bindings.vars || {})?.forEach(([key, value]) => {
+    if (typeof value === "string") {
+      metadataBindings.push({ name: key, type: "plain_text", text: value });
+    } else {
+      metadataBindings.push({ name: key, type: "json", json: value });
+    }
+  });
+
+  for (const [name, filePath] of Object.entries(bindings.wasm_modules || {})) {
+    metadataBindings.push({
+      name,
+      type: "wasm_module",
+      part: name,
+    });
+
+    formData.set(
+      name,
+      new File([readFileSync(filePath)], filePath, {
+        type: "application/wasm",
+      })
+    );
+  }
+
+  for (const [name, filePath] of Object.entries(bindings.text_blobs || {})) {
+    metadataBindings.push({
+      name,
+      type: "text_blob",
+      part: name,
+    });
+
+    if (name !== "__STATIC_CONTENT_MANIFEST") {
+      formData.set(
+        name,
+        new File([readFileSync(filePath)], filePath, {
+          type: "text/plain",
+        })
+      );
+    }
+  }
+
+  if (main.type === "commonjs") {
+    // This is a service-worker format worker.
+    for (const module of Object.values([...(modules || [])])) {
+      if (module.name === "__STATIC_CONTENT_MANIFEST") {
+        // Add the manifest to the form data.
+        formData.set(
+          module.name,
+          new File([module.content], module.name, {
+            type: "text/plain",
+          })
+        );
+        // And then remove it from the modules collection
+        modules = modules?.filter((m) => m !== module);
+      } else if (module.type === "compiled-wasm" || module.type === "text") {
+        // Convert all wasm/text modules into `wasm_module`/`text_blob` bindings.
+        // The "name" of the module is a file path. We use it
+        // to instead be a "part" of the body, and a reference
+        // that we can use inside our source. This identifier has to be a valid
+        // JS identifier, so we replace all non alphanumeric characters
+        // with an underscore.
+        const name = module.name.replace(/[^a-zA-Z0-9_$]/g, "_");
+        metadataBindings.push({
+          name,
+          type: module.type === "compiled-wasm" ? "wasm_module" : "text_blob",
+          part: name,
+        });
+
+        // Add the module to the form data.
+        formData.set(
+          name,
+          new File([module.content], module.name, {
+            type:
+              module.type === "compiled-wasm"
+                ? "application/wasm"
+                : "text/plain",
+          })
+        );
+        // And then remove it from the modules collection
+        modules = modules?.filter((m) => m !== module);
+      } else if (module.type === "buffer") {
+        throw new Error(
+          'The "buffer" module type is not yet supported in service worker format workers'
+        );
+      }
+    }
+  }
+
+  if (bindings.unsafe) {
+    // @ts-expect-error unsafe bindings don't need to match a specific type here
+    metadataBindings.push(...bindings.unsafe);
+  }
+
+  const metadata: WorkerMetadata = {
+    ...(main.type !== "commonjs"
+      ? { main_module: main.name }
+      : { body_part: main.name }),
+    bindings: metadataBindings,
+    ...(compatibility_date && { compatibility_date }),
+    ...(compatibility_flags && { compatibility_flags }),
+    ...(usage_model && { usage_model }),
+    ...(migrations && { migrations }),
+  };
+
+  formData.set("metadata", JSON.stringify(metadata));
+
+  if (main.type === "commonjs" && modules && modules.length > 0) {
+    throw new TypeError(
+      "More than one module can only be specified when type = 'esm'"
+    );
+  }
+
+  for (const module of [main].concat(modules || [])) {
+    formData.set(
+      module.name,
+      new File([module.content], module.name, {
+        type: toMimeType(module.type ?? main.type ?? "esm"),
+      })
+    );
+  }
+
+  return formData;
+}