wrangler 2.0.2 → 2.0.6

package/src/bundle.ts

@@ -1,5 +1,6 @@
 import assert from "node:assert";
 import * as fs from "node:fs";
+import { builtinModules } from "node:module";
 import * as path from "node:path";
 import NodeGlobalsPolyfills from "@esbuild-plugins/node-globals-polyfill";
 import NodeModulesPolyfills from "@esbuild-plugins/node-modules-polyfill";
@@ -16,6 +17,33 @@ type BundleResult = {
   stop: (() => void) | undefined;
 };
 
+/**
+ * Searches for any uses of node's builtin modules, and throws an error if it
+ * finds anything. This plugin is only used when nodeCompat is not enabled.
+ * Supports both regular node builtins, and the new "node:<MODULE>" format.
+ */
+const checkForNodeBuiltinsPlugin = {
+  name: "checkForNodeBuiltins",
+  setup(build: esbuild.PluginBuild) {
+    build.onResolve(
+      {
+        filter: new RegExp(
+          "^(" +
+            builtinModules.join("|") +
+            "|" +
+            builtinModules.map((module) => "node:" + module).join("|") +
+            ")$"
+        ),
+      },
+      () => {
+        throw new Error(
+          `Detected a Node builtin module import while Node compatibility is disabled.\nAdd node_compat = true to your wrangler.toml file to enable Node compatibility.`
+        );
+      }
+    );
+  },
+};
+
 /**
  * Generate a bundle for the worker identified by the arguments passed in.
  */
@@ -60,6 +88,7 @@ export async function bundleWorker(
     format: entry.format,
     rules,
   });
+
   const result = await esbuild.build({
     ...getEntryPoint(entry.file, serveAssetsFromWorker),
     bundle: true,
@@ -87,7 +116,9 @@ export async function bundleWorker(
       moduleCollector.plugin,
       ...(nodeCompat
         ? [NodeGlobalsPolyfills({ buffer: true }), NodeModulesPolyfills()]
-        : []),
+        : // we use checkForNodeBuiltinsPlugin to throw a nicer error
+          // if we find node builtins when nodeCompat isn't turned on
+          [checkForNodeBuiltinsPlugin]),
     ],
     ...(jsxFactory && { jsxFactory }),
     ...(jsxFragment && { jsxFragment }),

package/src/cfetch/internal.ts

@@ -112,6 +112,9 @@ function addAuthorizationHeader(
  * doesn't return json. We inline the implementation and try not to share
  * any code with the other calls. We should push back on any new APIs that
  * try to introduce non-"standard" response structures.
+ *
+ * Note: any calls to fetchKVGetValue must call encodeURIComponent on key
+ * before passing it
  */
 
 export async function fetchKVGetValue(

package/src/config/config.ts

@@ -161,7 +161,7 @@ export interface DevConfig {
    *
    * @default `8787`
    */
-  port: number;
+  port: number | undefined;
 
   /**
    * Protocol that local wrangler dev server listens to requests on.

package/src/config/environment.ts

@@ -8,6 +8,24 @@ export interface Environment
   extends EnvironmentInheritable,
     EnvironmentNonInheritable {}
 
+export type SimpleRoute = string;
+export type ZoneIdRoute = {
+  pattern: string;
+  zone_id: string;
+  custom_domain?: boolean;
+};
+export type ZoneNameRoute = {
+  pattern: string;
+  zone_name: string;
+  custom_domain?: boolean;
+};
+export type CustomDomainRoute = { pattern: string; custom_domain: boolean };
+export type Route =
+  | SimpleRoute
+  | ZoneIdRoute
+  | ZoneNameRoute
+  | CustomDomainRoute;
+
 /**
  * The `EnvironmentInheritable` interface declares all the configuration fields for an environment
  * that can be inherited (and overridden) from the top-level environment.
@@ -74,13 +92,7 @@ interface EnvironmentInheritable {
    *
    * @inheritable
    */
-  routes:
-    | (
-        | string
-        | { pattern: string; zone_id: string }
-        | { pattern: string; zone_name: string }
-      )[]
-    | undefined;
+  routes: Route[] | undefined;
 
   /**
    * A route that your worker should be published to. Literally
@@ -91,13 +103,7 @@ interface EnvironmentInheritable {
    *
    * @inheritable
    */
-  route:
-    | (
-        | string
-        | { pattern: string; zone_id: string }
-        | { pattern: string; zone_name: string }
-      )
-    | undefined;
+  route: Route | undefined;
 
   /**
    * Path to a custom tsconfig
@@ -236,6 +242,8 @@ interface EnvironmentNonInheritable {
       class_name: string;
       /** The script where the Durable Object is defined (if it's external to this worker) */
       script_name?: string;
+      /** The service environment of the script_name to bind to */
+      environment?: string;
     }[];
   };
 
@@ -279,6 +287,24 @@ interface EnvironmentNonInheritable {
     preview_bucket_name?: string;
   }[];
 
+  /**
+   * Specifies service bindings (worker-to-worker) that are bound to this Worker environment.
+   *
+   * NOTE: This field is not automatically inherited from the top level environment,
+   * and so must be specified in every named environment.
+   *
+   * @default `[]`
+   * @nonInheritable
+   */
+  services: {
+    /** The binding name used to refer to the bound service. */
+    binding: string;
+    /** The name of the service. */
+    service: string;
+    /** The environment of the service (e.g. production, staging, etc). */
+    environment?: string;
+  }[];
+
   /**
    * "Unsafe" tables for features that aren't directly supported by wrangler.
    *

package/src/config/validation.ts

@@ -352,7 +352,7 @@ function normalizeAndValidateDev(
 ): DevConfig {
   const {
     ip = "localhost",
-    port = 8787,
+    port,
     local_protocol = "http",
     upstream_protocol = "https",
     host,
@@ -562,19 +562,37 @@ function normalizeAndValidateModulePaths(
  * or an object that looks like {pattern: string, zone_id: string }
  */
 function isValidRouteValue(item: unknown): boolean {
-  return (
-    !!item &&
-    (typeof item === "string" ||
-      (typeof item === "object" &&
-        hasProperty(item, "pattern") &&
-        typeof item.pattern === "string" &&
-        // it could have a zone_name
-        ((hasProperty(item, "zone_name") &&
-          typeof item.zone_name === "string") ||
-          // or a zone_id
-          (hasProperty(item, "zone_id") && typeof item.zone_id === "string")) &&
-        Object.keys(item).length === 2))
-  );
+  if (!item) {
+    return false;
+  }
+  if (typeof item === "string") {
+    return true;
+  }
+  if (typeof item === "object") {
+    if (!hasProperty(item, "pattern") || typeof item.pattern !== "string") {
+      return false;
+    }
+
+    const otherKeys = Object.keys(item).length - 1; // minus one to subtract "pattern"
+
+    const hasZoneId =
+      hasProperty(item, "zone_id") && typeof item.zone_id === "string";
+    const hasZoneName =
+      hasProperty(item, "zone_name") && typeof item.zone_name === "string";
+    const hasCustomDomainFlag =
+      hasProperty(item, "custom_domain") &&
+      typeof item.custom_domain === "boolean";
+
+    if (otherKeys === 2 && hasCustomDomainFlag && (hasZoneId || hasZoneName)) {
+      return true;
+    } else if (
+      otherKeys === 1 &&
+      (hasZoneId || hasZoneName || hasCustomDomainFlag)
+    ) {
+      return true;
+    }
+  }
+  return false;
 }
 
 /**
@@ -583,7 +601,7 @@ function isValidRouteValue(item: unknown): boolean {
 const isRoute: ValidatorFn = (diagnostics, field, value) => {
   if (value !== undefined && !isValidRouteValue(value)) {
     diagnostics.errors.push(
-      `Expected "${field}" to be either a string, or an object with shape { pattern, zone_id | zone_name }, but got ${JSON.stringify(
+      `Expected "${field}" to be either a string, or an object with shape { pattern, custom_domain, zone_id | zone_name }, but got ${JSON.stringify(
         value
       )}.`
     );
@@ -613,7 +631,7 @@ const isRouteArray: ValidatorFn = (diagnostics, field, value) => {
   }
   if (invalidRoutes.length > 0) {
     diagnostics.errors.push(
-      `Expected "${field}" to be an array of either strings or objects with the shape { pattern, zone_id | zone_name }, but these weren't valid: ${JSON.stringify(
+      `Expected "${field}" to be an array of either strings or objects with the shape { pattern, custom_domain, zone_id | zone_name }, but these weren't valid: ${JSON.stringify(
         invalidRoutes,
         null,
         2
@@ -696,27 +714,12 @@ function normalizeAndValidateEnvironment(
     diagnostics,
     rawEnv,
     "experimental_services",
-    `The "experimental_services" field is no longer supported. Instead, use [[unsafe.bindings]] to enable experimental features. Add this to your wrangler.toml:\n` +
-      "```\n" +
-      TOML.stringify({
-        unsafe: {
-          bindings: (rawEnv?.experimental_services || []).map(
-            (serviceDefinition) => {
-              return {
-                name: serviceDefinition.name,
-                type: "service",
-                service: serviceDefinition.service,
-                environment: serviceDefinition.environment,
-              };
-            }
-          ),
-        },
-      }) +
-      "```",
+    `The "experimental_services" field is no longer supported. Simply rename the [experimental_services] field to [services].`,
     true
   );
 
   experimental(diagnostics, rawEnv, "unsafe");
+  experimental(diagnostics, rawEnv, "services");
 
   const route = validateRoute(diagnostics, topLevelEnv, rawEnv);
 
@@ -880,6 +883,16 @@ function normalizeAndValidateEnvironment(
       validateBindingArray(envName, validateR2Binding),
       []
     ),
+    services: notInheritable(
+      diagnostics,
+      topLevelEnv,
+      rawConfig,
+      rawEnv,
+      envName,
+      "services",
+      validateBindingArray(envName, validateServiceBinding),
+      []
+    ),
     unsafe: notInheritable(
       diagnostics,
       topLevelEnv,
@@ -1014,7 +1027,7 @@ const validateRule: ValidatorFn = (diagnostics, field, value) => {
 
   if (!isOptionalProperty(rule, "fallthrough", "boolean")) {
     diagnostics.errors.push(
-      `binding should, optionally, have a boolean "fallthrough" field.`
+      `the field "fallthrough", when present, should be a boolean.`
     );
     isValid = false;
   }
@@ -1135,7 +1148,7 @@ const validateDurableObjectBinding: ValidatorFn = (
     return false;
   }
 
-  // Durable Object bindings must have a name and class_name, and optionally a script_name.
+  // Durable Object bindings must have a name and class_name, and optionally a script_name and an environment.
   let isValid = true;
   if (!isRequiredProperty(value, "name", "string")) {
     diagnostics.errors.push(`binding should have a string "name" field.`);
@@ -1147,7 +1160,21 @@ const validateDurableObjectBinding: ValidatorFn = (
   }
   if (!isOptionalProperty(value, "script_name", "string")) {
     diagnostics.errors.push(
-      `binding should, optionally, have a string "script_name" field.`
+      `the field "script_name", when present, should be a string.`
+    );
+    isValid = false;
+  }
+  // environment requires a script_name
+  if (!isOptionalProperty(value, "environment", "string")) {
+    diagnostics.errors.push(
+      `the field "environment", when present, should be a string.`
+    );
+    isValid = false;
+  }
+
+  if ("environment" in value && !("script_name" in value)) {
+    diagnostics.errors.push(
+      `binding should have a "script_name" field if "environment" is present.`
     );
     isValid = false;
   }
@@ -1178,8 +1205,13 @@ const validateUnsafeBinding: ValidatorFn = (diagnostics, field, value) => {
     const safeBindings = [
       "plain_text",
       "json",
+      "wasm_module",
+      "data_blob",
+      "text_blob",
       "kv_namespace",
       "durable_object_namespace",
+      "r2_bucket",
+      "service",
     ];
 
     if (safeBindings.includes(value.type)) {
@@ -1422,3 +1454,38 @@ const validateBindingsHaveUniqueNames = (
 
   return !hasDuplicates;
 };
+const validateServiceBinding: ValidatorFn = (diagnostics, field, value) => {
+  if (typeof value !== "object" || value === null) {
+    diagnostics.errors.push(
+      `"services" bindings should be objects, but got ${JSON.stringify(value)}`
+    );
+    return false;
+  }
+  let isValid = true;
+  // Service bindings must have a binding, service, and environment.
+  if (!isRequiredProperty(value, "binding", "string")) {
+    diagnostics.errors.push(
+      `"${field}" bindings should have a string "binding" field but got ${JSON.stringify(
+        value
+      )}.`
+    );
+    isValid = false;
+  }
+  if (!isRequiredProperty(value, "service", "string")) {
+    diagnostics.errors.push(
+      `"${field}" bindings should have a string "service" field but got ${JSON.stringify(
+        value
+      )}.`
+    );
+    isValid = false;
+  }
+  if (!isOptionalProperty(value, "environment", "string")) {
+    diagnostics.errors.push(
+      `"${field}" bindings should have a string "environment" field but got ${JSON.stringify(
+        value
+      )}.`
+    );
+    isValid = false;
+  }
+  return isValid;
+};

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

@@ -32,20 +32,24 @@ export interface WorkerMetadata {
   compatibility_flags?: string[];
   usage_model?: "bundled" | "unbound";
   migrations?: CfDurableObjectMigrations;
+  // If you add any new binding types here, also add it to safeBindings
+  // under validateUnsafeBinding in config/validation.ts
   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: "data_blob"; name: string; part: string }
+    | { type: "kv_namespace"; name: string; namespace_id: string }
     | {
         type: "durable_object_namespace";
         name: string;
         class_name: string;
         script_name?: string;
+        environment?: string;
       }
     | { type: "r2_bucket"; name: string; bucket_name: string }
+    | { type: "service"; name: string; service: string; environment?: string }
   )[];
 }
 
@@ -67,6 +71,14 @@ export function createWorkerUploadForm(worker: CfWorkerInit): FormData {
 
   const metadataBindings: WorkerMetadata["bindings"] = [];
 
+  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 });
+    }
+  });
+
   bindings.kv_namespaces?.forEach(({ id, binding }) => {
     metadataBindings.push({
       name: binding,
@@ -76,12 +88,13 @@ export function createWorkerUploadForm(worker: CfWorkerInit): FormData {
   });
 
   bindings.durable_objects?.bindings.forEach(
-    ({ name, class_name, script_name }) => {
+    ({ name, class_name, script_name, environment }) => {
       metadataBindings.push({
         name,
         type: "durable_object_namespace",
         class_name: class_name,
         ...(script_name && { script_name }),
+        ...(environment && { environment }),
       });
     }
   );
@@ -94,12 +107,13 @@ export function createWorkerUploadForm(worker: CfWorkerInit): FormData {
     });
   });
 
-  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 });
-    }
+  bindings.services?.forEach(({ binding, service, environment }) => {
+    metadataBindings.push({
+      name: binding,
+      type: "service",
+      service,
+      ...(environment && { environment }),
+    });
   });
 
   for (const [name, filePath] of Object.entries(bindings.wasm_modules || {})) {

package/src/dev/dev.tsx

@@ -1,4 +1,5 @@
 import { spawn } from "node:child_process";
+import * as path from "node:path";
 import { watch } from "chokidar";
 import clipboardy from "clipboardy";
 import commandExists from "command-exists";
@@ -242,9 +243,11 @@ function useCustomBuild(
         persistent: true,
         ignoreInitial: true,
       }).on("all", (_event, filePath) => {
+        const relativeFile =
+          path.relative(expectedEntry.directory, expectedEntry.file) || ".";
         //TODO: we should buffer requests to the proxy until this completes
         logger.log(`The file ${filePath} changed, restarting build...`);
-        runCustomBuild(expectedEntry.file, build).catch((err) => {
+        runCustomBuild(expectedEntry.file, relativeFile, build).catch((err) => {
           logger.error("Custom build failed:", err);
         });
       });
@@ -253,7 +256,7 @@ function useCustomBuild(
     return () => {
       watcher?.close();
     };
-  }, [build, expectedEntry.file]);
+  }, [build, expectedEntry]);
 }
 
 function sleep(period: number) {

package/src/dev/local.tsx

@@ -87,6 +87,11 @@ function useLocalWorker({
           '⎔ A "public" folder is not yet supported in local mode.'
         );
       }
+      if (bindings.services && bindings.services.length > 0) {
+        throw new Error(
+          "⎔ Service bindings are not yet supported in local mode."
+        );
+      }
 
       // In local mode, we want to copy all referenced modules into
       // the output bundle directory before starting up
@@ -297,6 +302,7 @@ function useLocalWorker({
     bindings.durable_objects?.bindings,
     bindings.kv_namespaces,
     bindings.vars,
+    bindings.services,
     compatibilityDate,
     compatibilityFlags,
     localPersistencePath,

package/src/entry.ts

@@ -1,5 +1,5 @@
 import assert from "node:assert";
-import { existsSync } from "node:fs";
+import { existsSync, statSync } from "node:fs";
 import path from "node:path";
 import * as esbuild from "esbuild";
 import { execaCommand } from "execa";
@@ -45,11 +45,16 @@ export async function getEntry(
     file = path.resolve(directory, config.main);
   }
 
-  await runCustomBuild(file, config.build);
+  const relativeFile = path.relative(directory, file) || ".";
+  await runCustomBuild(file, relativeFile, config.build);
 
   if (fileExists(file) === false) {
     throw new Error(
-      `Could not resolve "${path.relative(process.cwd(), file)}".`
+      getMissingEntryPointMessage(
+        `The entry-point file at "${relativeFile}" was not found.`,
+        file,
+        relativeFile
+      )
     );
   }
   const format = await guessWorkerFormat(
@@ -90,7 +95,8 @@ export async function getEntry(
 }
 
 export async function runCustomBuild(
-  expectedEntry: string,
+  expectedEntryAbsolute: string,
+  expectedEntryRelative: string,
   build: Config["build"]
 ) {
   if (build?.command) {
@@ -105,12 +111,14 @@ export async function runCustomBuild(
       ...(build.cwd && { cwd: build.cwd }),
     });
 
-    if (fileExists(expectedEntry) === false) {
+    if (fileExists(expectedEntryAbsolute) === false) {
       throw new Error(
-        `Could not resolve "${path.relative(
-          process.cwd(),
-          expectedEntry
-        )}" after running custom build: ${build.command}`
+        getMissingEntryPointMessage(
+          `The expected output file at "${expectedEntryRelative}" was not found after running custom build: ${build.command}.\n` +
+            "The `main` property in wrangler.toml should point to the file generated by the custom build.",
+          expectedEntryAbsolute,
+          expectedEntryRelative
+        )
       );
     }
   }
@@ -265,3 +273,50 @@ function generateAddScriptNameExamples(
     })
     .join("\n");
 }
+
+/**
+ * Generate an appropriate message for when the entry-point is missing.
+ *
+ * To be more helpful to developers, we check whether there is a suitable file
+ * nearby to the expected file path.
+ */
+function getMissingEntryPointMessage(
+  message: string,
+  absoluteEntryPointPath: string,
+  relativeEntryPointPath: string
+): string {
+  if (
+    existsSync(absoluteEntryPointPath) &&
+    statSync(absoluteEntryPointPath).isDirectory()
+  ) {
+    // The expected entry-point is a directory, so offer further guidance.
+    message += `\nThe provided entry-point path, "${relativeEntryPointPath}", points to a directory, rather than a file.\n`;
+
+    // Perhaps we can even guess what the correct path should be...
+    const possiblePaths: string[] = [];
+    for (const basenamePath of [
+      "worker",
+      "dist/worker",
+      "index",
+      "dist/index",
+    ]) {
+      for (const extension of [".ts", ".tsx", ".js", ".jsx"]) {
+        const filePath = basenamePath + extension;
+        if (fileExists(path.resolve(absoluteEntryPointPath, filePath))) {
+          possiblePaths.push(path.join(relativeEntryPointPath, filePath));
+        }
+      }
+    }
+
+    if (possiblePaths.length > 0) {
+      message +=
+        `\nDid you mean to set the main field to${
+          possiblePaths.length > 1 ? " one of" : ""
+        }:\n` +
+        "```\n" +
+        possiblePaths.map((filePath) => `main = "./${filePath}"\n`).join("") +
+        "```";
+    }
+  }
+  return message;
+}