wrangler 0.0.0-e2a26a0 → 0.0.0-e3cab74

package/src/api/form_data.ts

@@ -1,8 +1,8 @@
+import { readFileSync } from "node:fs";
 import { FormData, File } from "undici";
 import type {
   CfWorkerInit,
   CfModuleType,
-  CfModule,
   CfDurableObjectMigrations,
 } from "./worker.js";
 
@@ -23,12 +23,6 @@ export function toMimeType(type: CfModuleType): string {
   }
 }
 
-function toModule(module: CfModule, entryType: CfModuleType): File {
-  const { type: moduleType, content } = module;
-  const type = toMimeType(moduleType ?? entryType);
-  return new File([content], module.name, { 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;
@@ -41,18 +35,16 @@ export interface WorkerMetadata {
   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: "service";
-        name: string;
-        service: string;
-        environment: string;
-      }
+    | { type: "r2_bucket"; name: string; bucket_name: string }
   )[];
 }
 
@@ -63,7 +55,6 @@ export function toFormData(worker: CfWorkerInit): FormData {
   const formData = new FormData();
   const {
     main,
-    modules,
     bindings,
     migrations,
     usage_model,
@@ -71,6 +62,8 @@ export function toFormData(worker: CfWorkerInit): FormData {
     compatibility_flags,
   } = worker;
 
+  let { modules } = worker;
+
   const metadataBindings: WorkerMetadata["bindings"] = [];
 
   bindings.kv_namespaces?.forEach(({ id, binding }) => {
@@ -92,18 +85,105 @@ export function toFormData(worker: CfWorkerInit): FormData {
     }
   );
 
+  bindings.r2_buckets?.forEach(({ binding, bucket_name }) => {
+    metadataBindings.push({
+      name: binding,
+      type: "r2_bucket",
+      bucket_name,
+    });
+  });
+
   Object.entries(bindings.vars || {})?.forEach(([key, value]) => {
-    metadataBindings.push({ name: key, type: "plain_text", text: value });
+    if (typeof value === "string") {
+      metadataBindings.push({ name: key, type: "plain_text", text: value });
+    } else {
+      metadataBindings.push({ name: key, type: "json", json: value });
+    }
   });
 
-  bindings.services?.forEach(({ name, service, environment }) => {
+  for (const [name, filePath] of Object.entries(bindings.wasm_modules || {})) {
     metadataBindings.push({
       name,
-      type: "service",
-      service,
-      environment,
+      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"
@@ -125,9 +205,12 @@ export function toFormData(worker: CfWorkerInit): FormData {
   }
 
   for (const module of [main].concat(modules || [])) {
-    const { name } = module;
-    const file = toModule(module, main.type ?? "esm");
-    formData.set(name, file);
+    formData.set(
+      module.name,
+      new File([module.content], module.name, {
+        type: toMimeType(module.type ?? main.type ?? "esm"),
+      })
+    );
   }
 
   return formData;

package/src/api/preview.ts

@@ -2,7 +2,7 @@ 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 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}/workers/edge-preview`
     : `/accounts/${accountId}/workers/subdomain/edge-preview`;
 
   const { exchange_url } = await fetchResult<{ exchange_url: string }>(initUrl);
@@ -92,15 +95,22 @@ function randomId(): string {
  */
 export async function previewToken(
   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
+  const mode: CfPreviewMode = ctx.zone
     ? { routes: ["*/*"] }
     : { workers_dev: true };
 
@@ -119,8 +129,17 @@ export async function previewToken(
     value: preview_token,
     // TODO: verify this works with zoned workers
     host:
-      worker.name && !zoneId
-        ? `${worker.name}.${host.split(".").slice(1).join(".")}`
+      worker.name && !ctx.zone
+        ? // hrmm this might need change as well
+          `${
+            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,

package/src/api/worker.ts

@@ -16,12 +16,13 @@ export interface CfAccount {
    * An account ID.
    */
   accountId: string;
-  /**
-   * A zone ID, only required if not using `workers.dev`.
-   */
-  zoneId?: string;
 }
 
+/**
+ * The type of Worker
+ */
+export type CfScriptFormat = "modules" | "service-worker";
+
 /**
  * A module type.
  */
@@ -66,7 +67,7 @@ export interface CfModule {
  * A map of variable names to values.
  */
 interface CfVars {
-  [key: string]: string;
+  [key: string]: unknown;
 }
 
 /**
@@ -77,6 +78,22 @@ interface CfKvNamespace {
   id: string;
 }
 
+/**
+ * A binding to a wasm module (in service worker format)
+ */
+
+interface CfWasmModuleBindings {
+  [key: string]: string;
+}
+
+/**
+ * A binding to a text blob (in service worker format)
+ */
+
+interface CfTextBlobBindings {
+  [key: string]: string;
+}
+
 /**
  * A Durable Object.
  */
@@ -86,13 +103,14 @@ interface CfDurableObject {
   script_name?: string;
 }
 
-/**
- * A Service.
- */
-interface CfService {
+interface CfR2Bucket {
+  binding: string;
+  bucket_name: string;
+}
+
+interface CfUnsafeBinding {
   name: string;
-  service: string;
-  environment: string;
+  type: string;
 }
 
 export interface CfDurableObjectMigrations {
@@ -100,7 +118,10 @@ export interface CfDurableObjectMigrations {
   new_tag: string;
   steps: {
     new_classes?: string[];
-    renamed_classes?: string[];
+    renamed_classes?: {
+      from: string;
+      to: string;
+    }[];
     deleted_classes?: string[];
   }[];
 }
@@ -125,10 +146,13 @@ export interface CfWorkerInit {
    * All the bindings
    */
   bindings: {
-    kv_namespaces?: CfKvNamespace[];
-    durable_objects?: { bindings: CfDurableObject[] };
-    vars?: CfVars;
-    services?: CfService[];
+    vars: CfVars | undefined;
+    kv_namespaces: CfKvNamespace[] | undefined;
+    wasm_modules: CfWasmModuleBindings | undefined;
+    text_blobs: CfTextBlobBindings | undefined;
+    durable_objects: { bindings: CfDurableObject[] } | undefined;
+    r2_buckets: CfR2Bucket[] | undefined;
+    unsafe: CfUnsafeBinding[] | undefined;
   };
   migrations: undefined | CfDurableObjectMigrations;
   compatibility_date: string | undefined;
@@ -136,6 +160,12 @@ export interface CfWorkerInit {
   usage_model: undefined | "bundled" | "unbound";
 }
 
+export interface CfWorkerContext {
+  env: string | undefined;
+  legacyEnv: boolean | undefined;
+  zone: string | undefined;
+}
+
 /**
  * A stub to create a Cloudflare Worker preview.
  *
@@ -144,9 +174,10 @@ export interface CfWorkerInit {
  */
 export async function createWorker(
   init: CfWorkerInit,
-  account: CfAccount
+  account: CfAccount,
+  ctx: CfWorkerContext
 ): Promise<CfPreviewToken> {
-  const token = await previewToken(account, init);
+  const token = await previewToken(account, init, ctx);
   const response = await fetch(token.prewarmUrl.href, { method: "POST" });
   if (!response.ok) {
     // console.error("worker failed to prewarm: ", response.statusText);

package/src/bundle.ts

@@ -0,0 +1,133 @@
+import assert from "node:assert";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import * as esbuild from "esbuild";
+import makeModuleCollector from "./module-collection";
+import type { CfModule, CfScriptFormat } from "./api/worker";
+import type { Config } from "./config";
+import type { Entry } from "./entry";
+
+type BundleResult = {
+  modules: CfModule[];
+  resolvedEntryPointPath: string;
+  bundleType: "esm" | "commonjs";
+  stop: (() => void) | undefined;
+};
+
+/**
+ * Generate a bundle for the worker identified by the arguments passed in.
+ */
+export async function bundleWorker(
+  entry: Entry,
+  destination: string,
+  options: {
+    serveAssetsFromWorker: boolean;
+    jsxFactory: string | undefined;
+    jsxFragment: string | undefined;
+    format: CfScriptFormat;
+    rules: Config["rules"];
+    watch?: esbuild.WatchMode;
+  }
+): Promise<BundleResult> {
+  const {
+    serveAssetsFromWorker,
+    jsxFactory,
+    jsxFragment,
+    format,
+    rules,
+    watch,
+  } = options;
+  const moduleCollector = makeModuleCollector({ format, rules });
+  const result = await esbuild.build({
+    ...getEntryPoint(entry.file, serveAssetsFromWorker),
+    bundle: true,
+    absWorkingDir: entry.directory,
+    outdir: destination,
+    external: ["__STATIC_CONTENT_MANIFEST"],
+    format: "esm",
+    sourcemap: true,
+    metafile: true,
+    conditions: ["worker", "browser"],
+    loader: {
+      ".js": "jsx",
+      ".mjs": "jsx",
+      ".cjs": "jsx",
+    },
+    plugins: [moduleCollector.plugin],
+    ...(jsxFactory && { jsxFactory }),
+    ...(jsxFragment && { jsxFragment }),
+    watch,
+  });
+
+  const entryPointOutputs = Object.entries(result.metafile.outputs).filter(
+    ([_path, output]) => output.entryPoint !== undefined
+  );
+  assert(
+    entryPointOutputs.length > 0,
+    `Cannot find entry-point "${entry.file}" in generated bundle.` +
+      listEntryPoints(entryPointOutputs)
+  );
+  assert(
+    entryPointOutputs.length < 2,
+    "More than one entry-point found for generated bundle." +
+      listEntryPoints(entryPointOutputs)
+  );
+
+  const entryPointExports = entryPointOutputs[0][1].exports;
+  const bundleType = entryPointExports.length > 0 ? "esm" : "commonjs";
+
+  return {
+    modules: moduleCollector.modules,
+    resolvedEntryPointPath: path.resolve(
+      entry.directory,
+      entryPointOutputs[0][0]
+    ),
+    bundleType,
+    stop: result.stop,
+  };
+}
+
+type EntryPoint =
+  | { stdin: esbuild.StdinOptions; nodePaths: string[] }
+  | { entryPoints: string[] };
+
+/**
+ * Create an object that describes the entry point for esbuild.
+ *
+ * If we are using the experimental asset handling, then the entry point is
+ * actually a shim worker that will either return an asset from a KV store,
+ * or delegate to the actual worker.
+ */
+function getEntryPoint(
+  entryFile: string,
+  serveAssetsFromWorker: boolean
+): EntryPoint {
+  if (serveAssetsFromWorker) {
+    return {
+      stdin: {
+        contents: fs
+          .readFileSync(
+            path.join(__dirname, "../templates/static-asset-facade.js"),
+            "utf8"
+          )
+          .replace("__ENTRY_POINT__", entryFile),
+        sourcefile: "static-asset-facade.js",
+        resolveDir: path.dirname(entryFile),
+      },
+      nodePaths: [path.join(__dirname, "../vendor")],
+    };
+  } else {
+    return { entryPoints: [entryFile] };
+  }
+}
+
+/**
+ * Generate a string that describes the entry-points that were identified by esbuild.
+ */
+function listEntryPoints(
+  outputs: [string, ValueOf<esbuild.Metafile["outputs"]>][]
+): string {
+  return outputs.map(([_input, output]) => output.entryPoint).join("\n");
+}
+
+type ValueOf<T> = T[keyof T];

package/src/cfetch/index.ts

@@ -1,10 +1,11 @@
 import { URLSearchParams } from "node:url";
+import { ParseError } from "../parse";
 import { fetchInternal } from "./internal";
 import type { RequestInit } from "undici";
 
 // Check out https://api.cloudflare.com/ for API docs.
 
-export { CF_API_BASE_URL } from "./internal";
+export { getCloudflareAPIBaseURL as getCloudflareApiBaseUrl } from "./internal";
 
 export interface FetchError {
   code: number;
@@ -81,11 +82,12 @@ function throwFetchError(
   resource: string,
   response: FetchResult<unknown>
 ): never {
-  response.messages.forEach((message) => console.warn(message));
-  const errors = response.errors
-    .map((error) => `${error.code}: ${error.message}`)
-    .join("\n");
-  const error = new Error(`Failed to fetch ${resource} - \n${errors}`);
+  const error = new ParseError({
+    text: "Received a bad response from the API",
+    notes: response.errors.map((err) => ({
+      text: err.code ? `${err.message} [code: ${err.code}]` : err.message,
+    })),
+  });
   // add the first error code directly to this error
   // so consumers can use it for specific behaviour
   const code = response.errors[0]?.code;

package/src/cfetch/internal.ts

@@ -1,10 +1,18 @@
 import { fetch } from "undici";
+import { getEnvironmentVariableFactory } from "../environment-variables";
+import { ParseError, parseJSON } from "../parse";
 import { getAPIToken, loginOrRefreshIfRequired } from "../user";
 import type { URLSearchParams } from "node:url";
 import type { RequestInit, HeadersInit } from "undici";
 
-export const CF_API_BASE_URL =
-  process.env.CF_API_BASE_URL || "https://api.cloudflare.com/client/v4";
+/**
+ * Get the URL to use to access the Cloudflare API.
+ */
+export const getCloudflareAPIBaseURL = getEnvironmentVariableFactory({
+  variableName: "CLOUDFLARE_API_BASE_URL",
+  deprecatedName: "CF_API_BASE_URL",
+  defaultValue: "https://api.cloudflare.com/client/v4",
+});
 
 /**
  * Make a fetch request to the Cloudflare API.
@@ -26,23 +34,44 @@ export async function fetchInternal<ResponseType>(
   addAuthorizationHeader(headers, apiToken);
 
   const queryString = queryParams ? `?${queryParams.toString()}` : "";
-  const response = await fetch(`${CF_API_BASE_URL}${resource}${queryString}`, {
-    method: "GET",
-    ...init,
-    headers,
-  });
+  const method = init.method ?? "GET";
+  const response = await fetch(
+    `${getCloudflareAPIBaseURL()}${resource}${queryString}`,
+    {
+      method,
+      ...init,
+      headers,
+    }
+  );
   const jsonText = await response.text();
   try {
-    const json = JSON.parse(jsonText);
-    return json as ResponseType;
-  } catch (e) {
-    throw new Error(
-      `Failed to fetch ${resource} - ${response.status}: ${response.statusText}\nInvalid JSON response:\n${jsonText}`
-    );
+    return parseJSON(jsonText) as ResponseType;
+  } catch (err) {
+    throw new ParseError({
+      text: "Received a malformed response from the API",
+      notes: [
+        {
+          text: truncate(jsonText, 100),
+        },
+        {
+          text: `${method} ${resource} -> ${response.status} ${response.statusText}`,
+        },
+      ],
+    });
+  }
+}
+
+function truncate(text: string, maxLength: number): string {
+  const { length } = text;
+  if (length <= maxLength) {
+    return text;
   }
+  return `${text.substring(0, maxLength)}... (length = ${length})`;
 }
 
-function cloneHeaders(headers: HeadersInit | undefined): HeadersInit {
+function cloneHeaders(
+  headers: HeadersInit | undefined
+): Record<string, string> {
   return { ...headers };
 }
 
@@ -61,8 +90,11 @@ function requireApiToken(): string {
   return apiToken;
 }
 
-function addAuthorizationHeader(headers: HeadersInit, apiToken: string): void {
-  if (headers["Authorization"]) {
+function addAuthorizationHeader(
+  headers: Record<string, string>,
+  apiToken: string
+): void {
+  if ("Authorization" in headers) {
     throw new Error(
       "The request already specifies an authorisation header - cannot add a new one."
     );
@@ -86,7 +118,7 @@ export async function fetchKVGetValue(
   await requireLoggedIn();
   const apiToken = requireApiToken();
   const headers = { Authorization: `Bearer ${apiToken}` };
-  const resource = `${CF_API_BASE_URL}/accounts/${accountId}/storage/kv/namespaces/${namespaceId}/values/${key}`;
+  const resource = `${getCloudflareAPIBaseURL()}/accounts/${accountId}/storage/kv/namespaces/${namespaceId}/values/${key}`;
   const response = await fetch(resource, {
     method: "GET",
     headers,

package/src/cli.ts

@@ -1,6 +1,16 @@
+import process from "process";
 import { hideBin } from "yargs/helpers";
+import { reportError, initReporting } from "./reporting";
 import { main } from ".";
 
+try {
+  initReporting();
+} catch (error) {}
+
+process.on("uncaughtExceptionMonitor", async (err, origin) => {
+  await reportError(err, origin);
+});
+
 main(hideBin(process.argv)).catch(() => {
   // The logging of any error that was thrown from `main()` is handled in the `yargs.fail()` handler.
   // Here we just want to ensure that the process exits with a non-zero code.