wrangler 0.0.0-e1c615f → 0.0.0-e3cab74

package/src/api/form_data.ts

@@ -1,10 +1,10 @@
+import { readFileSync } from "node:fs";
+import { FormData, File } from "undici";
 import type {
   CfWorkerInit,
   CfModuleType,
-  CfModule,
   CfDurableObjectMigrations,
 } from "./worker.js";
-import { FormData, Blob } from "formdata-node";
 
 export function toMimeType(type: CfModuleType): string {
   switch (type) {
@@ -23,14 +23,11 @@ export function toMimeType(type: CfModuleType): string {
   }
 }
 
-function toModule(module: CfModule, entryType?: CfModuleType): Blob {
-  const { type: moduleType, content } = module;
-  const type = toMimeType(moduleType ?? entryType);
-
-  return new Blob([content], { type });
-}
-
-interface WorkerMetadata {
+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";
@@ -38,18 +35,16 @@ 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 }
   )[];
 }
 
@@ -60,7 +55,6 @@ export function toFormData(worker: CfWorkerInit): FormData {
   const formData = new FormData();
   const {
     main,
-    modules,
     bindings,
     migrations,
     usage_model,
@@ -68,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 }) => {
@@ -89,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"
@@ -122,9 +205,12 @@ export function toFormData(worker: CfWorkerInit): FormData {
   }
 
   for (const module of [main].concat(modules || [])) {
-    const { name } = module;
-    const blob = toModule(module, main.type ?? "esm");
-    formData.set(name, blob, name);
+    formData.set(
+      module.name,
+      new File([module.content], module.name, {
+        type: toMimeType(module.type ?? main.type ?? "esm"),
+      })
+    );
   }
 
   return formData;

package/src/api/preview.ts

@@ -1,7 +1,8 @@
-import fetch from "node-fetch";
+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.
@@ -54,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);
@@ -91,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 };
 
@@ -108,7 +119,6 @@ export async function previewToken(
 
   const { preview_token } = await fetchResult<{ preview_token: string }>(url, {
     method: "POST",
-    // @ts-expect-error TODO: fix this
     body: formData,
     headers: {
       "cf-preview-upload-config-token": value,
@@ -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

@@ -1,6 +1,6 @@
-import type { CfPreviewToken } from "./preview";
+import { fetch } from "undici";
 import { previewToken } from "./preview";
-import fetch from "node-fetch";
+import type { CfPreviewToken } from "./preview";
 
 /**
  * A Cloudflare account.
@@ -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.
  */
@@ -53,7 +54,7 @@ export interface CfModule {
    *   }
    * }
    */
-  content: string | BufferSource;
+  content: string | Buffer;
   /**
    * The 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[];
   }[];
 }
@@ -112,7 +133,7 @@ export interface CfWorkerInit {
   /**
    * The name of the worker.
    */
-  name: string | void;
+  name: string | undefined;
   /**
    * The entrypoint module.
    */
@@ -120,20 +141,29 @@ export interface CfWorkerInit {
   /**
    * The list of additional modules.
    */
-  modules: void | CfModule[];
+  modules: undefined | CfModule[];
   /**
    * 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: void | CfDurableObjectMigrations;
-  compatibility_date: string | void;
-  compatibility_flags: void | string[];
-  usage_model: void | "bundled" | "unbound";
+  migrations: undefined | CfDurableObjectMigrations;
+  compatibility_date: string | undefined;
+  compatibility_flags: undefined | string[];
+  usage_model: undefined | "bundled" | "unbound";
+}
+
+export interface CfWorkerContext {
+  env: string | undefined;
+  legacyEnv: boolean | undefined;
+  zone: string | undefined;
 }
 
 /**
@@ -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 type { RequestInit } from "node-fetch";
-import { URLSearchParams } from "url";
+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;
@@ -18,16 +19,7 @@ export interface FetchResult<ResponseType = unknown> {
   result_info?: unknown;
 }
 
-/**
- * Make a fetch request for a raw JSON value.
- */
-export async function fetchRaw<ResponseType>(
-  resource: string,
-  init: RequestInit = {},
-  queryParams?: URLSearchParams
-): Promise<ResponseType> {
-  return fetchInternal<ResponseType>(resource, init, queryParams);
-}
+export { fetchKVGetValue } from "./internal";
 
 /**
  * Make a fetch request, and extract the `result` from the JSON response.
@@ -90,13 +82,23 @@ 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");
-  throw new Error(`Failed to fetch ${resource} - ${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;
+  if (code) {
+    //@ts-expect-error non-standard property on Error
+    error.code = code;
+  }
+  throw error;
 }
 
 function hasCursor(result_info: unknown): result_info is { cursor: string } {
-  return (result_info as { cursor } | undefined)?.cursor !== undefined;
+  const cursor = (result_info as { cursor: string } | undefined)?.cursor;
+  return cursor !== undefined && cursor !== null && cursor !== "";
 }