wrangler 0.0.0-e3cab74 → 0.0.0-e452a35

package/src/config/validation.ts

@@ -19,11 +19,24 @@ import {
   validateOptionalTypedArray,
   validateRequiredProperty,
   validateTypedArray,
+  all,
+  isMutuallyExclusiveWith,
+  inheritableInLegacyEnvironments,
+  appendEnvName,
+  getBindingNames,
+  isValidName,
 } from "./validation-helpers";
-import type { Config, DeprecatedUpload, RawConfig } from "./config";
-import type { RawEnvironment, Environment, Rule } from "./environment";
+import type { Config, DevConfig, RawConfig, RawDevConfig } from "./config";
+import type {
+  RawEnvironment,
+  DeprecatedUpload,
+  Environment,
+  Rule,
+} from "./environment";
 import type { ValidatorFn } from "./validation-helpers";
 
+const ENGLISH = new Intl.ListFormat("en");
+
 /**
  * Validate the given `rawConfig` object that was loaded from `configPath`.
  *
@@ -34,7 +47,8 @@ import type { ValidatorFn } from "./validation-helpers";
  */
 export function normalizeAndValidateConfig(
   rawConfig: RawConfig,
-  configPath: string | undefined
+  configPath: string | undefined,
+  args: unknown
 ): {
   config: Config;
   diagnostics: Diagnostics;
@@ -48,23 +62,28 @@ export function normalizeAndValidateConfig(
   deprecated(
     diagnostics,
     rawConfig,
-    "type",
-    "DO NOT USE THIS. Most common features now work out of the box with wrangler, including modules, jsx, typescript, etc. If you need anything more, use a custom build.",
-    true
+    "miniflare",
+    "Wrangler does not use configuration in the `miniflare` section. Unless you are using Miniflare directly you can remove this section.",
+    true,
+    "😶 Ignored"
   );
 
   deprecated(
     diagnostics,
     rawConfig,
-    "webpack_config",
-    "DO NOT USE THIS. Most common features now work out of the box with wrangler, including modules, jsx, typescript, etc. If you need anything more, use a custom build.",
-    true
+    "type",
+    "Most common features now work out of the box with wrangler, including modules, jsx, typescript, etc. If you need anything more, use a custom build.",
+    true,
+    "😶 Ignored"
   );
 
-  const { deprecatedUpload, ...build } = normalizeAndValidateBuild(
+  deprecated(
     diagnostics,
     rawConfig,
-    rawConfig.build ?? {}
+    "webpack_config",
+    "Most common features now work out of the box with wrangler, including modules, jsx, typescript, etc. If you need anything more, use a custom build.",
+    true,
+    "😶 Ignored"
   );
 
   validateOptionalProperty(
@@ -75,29 +94,98 @@ export function normalizeAndValidateConfig(
     "boolean"
   );
 
+  // TODO: set the default to false to turn on service environments as the default
+  const isLegacyEnv =
+    (args as { "legacy-env": boolean | undefined })["legacy-env"] ??
+    rawConfig.legacy_env ??
+    true;
+
+  // TODO: remove this once service environments goes GA.
+  if (!isLegacyEnv) {
+    diagnostics.warnings.push(
+      "Experimental: Service environments are in beta, and their behaviour is guaranteed to change in the future. DO NOT USE IN PRODUCTION."
+    );
+  }
+
+  const topLevelEnv = normalizeAndValidateEnvironment(
+    diagnostics,
+    configPath,
+    rawConfig
+  );
+
+  //TODO: find a better way to define the type of Args that can be passed to the normalizeAndValidateConfig()
+  const envName = (args as { env: string | undefined }).env;
+
+  let activeEnv = topLevelEnv;
+  if (envName !== undefined) {
+    const envDiagnostics = new Diagnostics(
+      `"env.${envName}" environment configuration`
+    );
+    const rawEnv = rawConfig.env?.[envName];
+    if (rawEnv !== undefined) {
+      activeEnv = normalizeAndValidateEnvironment(
+        envDiagnostics,
+        configPath,
+        rawEnv,
+        envName,
+        topLevelEnv,
+        isLegacyEnv,
+        rawConfig
+      );
+      diagnostics.addChild(envDiagnostics);
+    } else {
+      // An environment was specified, but no configuration for it was found.
+      // To cover any legacy environment cases, where the `envName` is used,
+      // Let's create a fake active environment with the specified `envName`.
+      activeEnv = normalizeAndValidateEnvironment(
+        envDiagnostics,
+        configPath,
+        {},
+        envName,
+        topLevelEnv,
+        isLegacyEnv,
+        rawConfig
+      );
+      const envNames = rawConfig.env
+        ? `The available configured environment names are: ${JSON.stringify(
+            Object.keys(rawConfig.env)
+          )}\n`
+        : "";
+      const message =
+        `No environment found in configuration with name "${envName}".\n` +
+        `Before using \`--env=${envName}\` there should be an equivalent environment section in the configuration.\n` +
+        `${envNames}\n` +
+        `Consider adding an environment configuration section to the wrangler.toml file:\n` +
+        "```\n[env." +
+        envName +
+        "]\n```\n";
+
+      if (envNames.length > 0) {
+        diagnostics.errors.push(message);
+      } else {
+        // Only warn (rather than error) if there are not actually any environments configured in wrangler.toml.
+        diagnostics.warnings.push(message);
+      }
+    }
+  }
+
   // Process the top-level default environment configuration.
   const config: Config = {
     configPath,
-    main: normalizeAndValidateMainField(
+    legacy_env: isLegacyEnv,
+    ...activeEnv,
+    dev: normalizeAndValidateDev(diagnostics, rawConfig.dev ?? {}),
+    migrations: normalizeAndValidateMigrations(
       diagnostics,
-      configPath,
-      rawConfig.main,
-      deprecatedUpload
+      rawConfig.migrations ?? [],
+      activeEnv.durable_objects
     ),
-    // TODO: set the default to false to turn on service environments as the default
-    legacy_env: rawConfig.legacy_env ?? true,
-    ...normalizeAndValidateEnvironment(
+    site: normalizeAndValidateSite(
       diagnostics,
+      configPath,
       rawConfig,
-      deprecatedUpload.rules
-    ),
-    env: {}, // Will be filled below by `normalizeAndValidateEnvironment()`.
-    dev: normalizeAndValidateDev(diagnostics, rawConfig.dev ?? {}),
-    migrations: normalizeAndValidateMigrations(
-      diagnostics,
-      rawConfig.migrations ?? []
+      activeEnv.main
     ),
-    site: normalizeAndValidateSite(diagnostics, rawConfig.site),
     wasm_modules: normalizeAndValidateModulePaths(
       diagnostics,
       configPath,
@@ -110,33 +198,21 @@ export function normalizeAndValidateConfig(
       "text_blobs",
       rawConfig.text_blobs
     ),
-    build,
+    data_blobs: normalizeAndValidateModulePaths(
+      diagnostics,
+      configPath,
+      "data_blobs",
+      rawConfig.data_blobs
+    ),
   };
 
-  // Process each of the specific environment configurations.
-  if (rawConfig.env !== undefined) {
-    for (const envName of Object.keys(rawConfig.env)) {
-      const envDiagnostics = new Diagnostics(
-        `"env.${envName}" environment configuration`
-      );
-      const environment = normalizeAndValidateEnvironment(
-        envDiagnostics,
-        rawConfig.env[envName] as RawEnvironment,
-        deprecatedUpload.rules,
-        envName,
-        config,
-        rawConfig
-      );
-      config.env[envName] = environment;
-      diagnostics.addChild(envDiagnostics);
-    }
-  }
+  validateBindingsHaveUniqueNames(diagnostics, config);
 
   validateAdditionalProperties(
     diagnostics,
     "top-level",
     Object.keys(rawConfig),
-    Object.keys(config)
+    [...Object.keys(config), "env"]
   );
 
   return { config, diagnostics };
@@ -147,8 +223,9 @@ export function normalizeAndValidateConfig(
  */
 function normalizeAndValidateBuild(
   diagnostics: Diagnostics,
-  rawConfig: RawConfig,
-  rawBuild: Config["build"]
+  rawEnv: RawEnvironment,
+  rawBuild: Config["build"],
+  configPath: string | undefined
 ): Config["build"] & { deprecatedUpload: DeprecatedUpload } {
   const { command, cwd, watch_dir, upload, ...rest } = rawBuild;
   const deprecatedUpload: DeprecatedUpload = { ...upload };
@@ -166,13 +243,13 @@ function normalizeAndValidateBuild(
 
   deprecated(
     diagnostics,
-    rawConfig,
+    rawEnv,
     "build.upload.format",
     "The format is inferred automatically from the code.",
     true
   );
 
-  if (rawConfig.main !== undefined && rawBuild.upload?.main) {
+  if (rawEnv.main !== undefined && rawBuild.upload?.main) {
     diagnostics.errors.push(
       `Don't define both the \`main\` and \`build.upload.main\` fields in your configuration.\n` +
         `They serve the same purpose: to point to the entry-point of your worker.\n` +
@@ -181,7 +258,7 @@ function normalizeAndValidateBuild(
   } else {
     deprecated(
       diagnostics,
-      rawConfig,
+      rawEnv,
       "build.upload.main",
       `Delete the \`build.upload.main\` and \`build.upload.dir\` fields.\n` +
         `Then add the top level \`main\` field to your configuration file:\n` +
@@ -196,24 +273,41 @@ function normalizeAndValidateBuild(
 
     deprecated(
       diagnostics,
-      rawConfig,
+      rawEnv,
       "build.upload.dir",
       `Use the top level "main" field or a command-line argument to specify the entry-point for the Worker.`,
       true
     );
   }
 
-  return { command, cwd, watch_dir, deprecatedUpload };
+  return {
+    command,
+    watch_dir:
+      // - `watch_dir` only matters when `command` is defined, so we apply
+      // a default only when `command` is defined
+      // - `configPath` will always be defined since `build` can only
+      // be configured in `wrangler.toml`, but who knows, that may
+      // change in the future, so we do a check anyway
+      command
+        ? configPath
+          ? path.relative(
+              process.cwd(),
+              path.join(path.dirname(configPath), watch_dir || "./src")
+            )
+          : watch_dir || "./src"
+        : watch_dir,
+    cwd,
+    deprecatedUpload,
+  };
 }
 
 /**
  * Validate the `main` field and return the normalized values.
  */
 function normalizeAndValidateMainField(
-  diagnostics: Diagnostics,
   configPath: string | undefined,
   rawMain: string | undefined,
-  deprecatedUpload: { dir?: string; main?: string }
+  deprecatedUpload: DeprecatedUpload | undefined
 ): string | undefined {
   const configDir = path.dirname(configPath ?? "wrangler.toml");
   if (rawMain !== undefined) {
@@ -221,13 +315,13 @@ function normalizeAndValidateMainField(
       const directory = path.resolve(configDir);
       return path.resolve(directory, rawMain);
     } else {
-      diagnostics.errors.push(
-        `ERROR: "main" should be a string but got ${JSON.stringify(rawMain)}`
-      );
-      return;
+      return rawMain;
     }
-  } else if (deprecatedUpload.main !== undefined) {
-    const directory = path.resolve(configDir, deprecatedUpload.dir || "./dist");
+  } else if (deprecatedUpload?.main !== undefined) {
+    const directory = path.resolve(
+      configDir,
+      deprecatedUpload?.dir || "./dist"
+    );
     return path.resolve(directory, deprecatedUpload.main);
   } else {
     return;
@@ -239,13 +333,14 @@ function normalizeAndValidateMainField(
  */
 function normalizeAndValidateDev(
   diagnostics: Diagnostics,
-  rawDev: Config["dev"]
-): Config["dev"] {
+  rawDev: RawDevConfig
+): DevConfig {
   const {
-    ip = "127.0.0.1",
-    port = 8787,
+    ip = "localhost",
+    port,
     local_protocol = "http",
     upstream_protocol = "https",
+    host,
     ...rest
   } = rawDev;
   validateAdditionalProperties(diagnostics, "dev", Object.keys(rest), []);
@@ -257,16 +352,19 @@ function normalizeAndValidateDev(
     "dev",
     "local_protocol",
     local_protocol,
-    "string"
+    "string",
+    ["http", "https"]
   );
   validateOptionalProperty(
     diagnostics,
     "dev",
     "upstream_protocol",
     upstream_protocol,
-    "string"
+    "string",
+    ["http", "https"]
   );
-  return { ip, port, local_protocol, upstream_protocol };
+  validateOptionalProperty(diagnostics, "dev", "host", host, "string");
+  return { ip, port, local_protocol, upstream_protocol, host };
 }
 
 /**
@@ -274,7 +372,8 @@ function normalizeAndValidateDev(
  */
 function normalizeAndValidateMigrations(
   diagnostics: Diagnostics,
-  rawMigrations: Config["migrations"]
+  rawMigrations: Config["migrations"],
+  durableObjects: Config["durable_objects"]
 ): Config["migrations"] {
   if (!Array.isArray(rawMigrations)) {
     diagnostics.errors.push(
@@ -302,7 +401,7 @@ function normalizeAndValidateMigrations(
       if (migration.renamed_classes !== undefined) {
         if (!Array.isArray(migration.renamed_classes)) {
           diagnostics.errors.push(
-            `"migrations[${i}].renamed_classes" should be an array of "{from: string, to: string}" objects but got ${JSON.stringify(
+            `Expected "migrations[${i}].renamed_classes" to be an array of "{from: string, to: string}" objects but got ${JSON.stringify(
               migration.renamed_classes
             )}.`
           );
@@ -315,7 +414,7 @@ function normalizeAndValidateMigrations(
           )
         ) {
           diagnostics.errors.push(
-            `"migrations[${i}].renamed_classes" should be an array of "{from: string, to: string}" objects but got ${JSON.stringify(
+            `Expected "migrations[${i}].renamed_classes" to be an array of "{from: string, to: string}" objects but got ${JSON.stringify(
               migration.renamed_classes
             )}.`
           );
@@ -328,6 +427,45 @@ function normalizeAndValidateMigrations(
         "string"
       );
     }
+
+    if (
+      Array.isArray(durableObjects?.bindings) &&
+      durableObjects.bindings.length > 0
+    ) {
+      // intrinsic [durable_objects] implies [migrations]
+      const exportedDurableObjects = (durableObjects.bindings || []).filter(
+        (binding) => !binding.script_name
+      );
+      if (exportedDurableObjects.length > 0 && rawMigrations.length === 0) {
+        if (
+          !exportedDurableObjects.some(
+            (exportedDurableObject) =>
+              typeof exportedDurableObject.class_name !== "string"
+          )
+        ) {
+          const durableObjectClassnames = exportedDurableObjects.map(
+            (durable) => durable.class_name
+          );
+
+          diagnostics.warnings.push(
+            `In wrangler.toml, you have configured [durable_objects] exported by this Worker (${durableObjectClassnames.join(
+              ", "
+            )}), but no [migrations] for them. This may not work as expected until you add a [migrations] section to your wrangler.toml. Add this configuration to your wrangler.toml:
+
+  \`\`\`
+  [[migrations]]
+  tag = "v1" # Should be unique for each entry
+  new_classes = [${durableObjectClassnames
+    .map((name) => `"${name}"`)
+    .join(", ")}]
+  \`\`\`
+
+Refer to https://developers.cloudflare.com/workers/learning/using-durable-objects/#durable-object-migrations-in-wranglertoml for more details.`
+          );
+        }
+      }
+    }
+
     return rawMigrations;
   }
 }
@@ -337,39 +475,91 @@ function normalizeAndValidateMigrations(
  */
 function normalizeAndValidateSite(
   diagnostics: Diagnostics,
-  rawSite: Config["site"]
+  configPath: string | undefined,
+  rawConfig: RawConfig,
+  mainEntryPoint: string | undefined
 ): Config["site"] {
-  if (rawSite !== undefined) {
-    const {
-      bucket,
-      "entry-point": entryPoint,
-      include = [],
-      exclude = [],
-      ...rest
-    } = rawSite;
-    validateAdditionalProperties(diagnostics, "site", Object.keys(rest), []);
+  if (rawConfig?.site !== undefined) {
+    const { bucket, include = [], exclude = [], ...rest } = rawConfig.site;
+
+    validateAdditionalProperties(diagnostics, "site", Object.keys(rest), [
+      "entry-point",
+    ]);
     validateRequiredProperty(diagnostics, "site", "bucket", bucket, "string");
+    validateTypedArray(diagnostics, "sites.include", include, "string");
+    validateTypedArray(diagnostics, "sites.exclude", exclude, "string");
     validateOptionalProperty(
       diagnostics,
       "site",
-      "entry_point",
-      entryPoint,
+      "entry-point",
+      rawConfig.site["entry-point"],
       "string"
     );
-    validateTypedArray(diagnostics, "sites.include", include, "string");
-    validateTypedArray(diagnostics, "sites.exclude", exclude, "string");
-    return { bucket, "entry-point": entryPoint, include, exclude };
+
+    deprecated(
+      diagnostics,
+      rawConfig,
+      `site.entry-point`,
+      `Delete the \`site.entry-point\` field, then add the top level \`main\` field to your configuration file:\n` +
+        `\`\`\`\n` +
+        `main = "${path.join(
+          String(rawConfig.site["entry-point"]) || "workers-site",
+          path.extname(String(rawConfig.site["entry-point"]) || "workers-site")
+            ? ""
+            : "index.js"
+        )}"\n` +
+        `\`\`\``,
+      false,
+      undefined,
+      "warning"
+    );
+
+    let siteEntryPoint = rawConfig.site["entry-point"];
+
+    if (!mainEntryPoint && !siteEntryPoint) {
+      // this means that we're defaulting to "workers-site"
+      // so let's add the deprecation warning
+      diagnostics.warnings.push(
+        `Because you've defined a [site] configuration, we're defaulting to "workers-site" for the deprecated \`site.entry-point\`field.\n` +
+          `Add the top level \`main\` field to your configuration file:\n` +
+          `\`\`\`\n` +
+          `main = "workers-site/index.js"\n` +
+          `\`\`\``
+      );
+      siteEntryPoint = "workers-site";
+    } else if (mainEntryPoint && siteEntryPoint) {
+      diagnostics.errors.push(
+        `Don't define both the \`main\` and \`site.entry-point\` fields in your configuration.\n` +
+          `They serve the same purpose: to point to the entry-point of your worker.\n` +
+          `Delete the deprecated \`site.entry-point\` field from your config.`
+      );
+    }
+
+    if (configPath && siteEntryPoint) {
+      // rewrite the path to be relative to the working directory
+      siteEntryPoint = path.relative(
+        process.cwd(),
+        path.join(path.dirname(configPath), siteEntryPoint)
+      );
+    }
+
+    return {
+      bucket,
+      "entry-point": siteEntryPoint,
+      include,
+      exclude,
+    };
   }
   return undefined;
 }
 
 /**
- * Map the paths of the `wasm_modules` or `text_blobs` configuration to be relative to the current working directory.
+ * Map the paths of the `wasm_modules`, `text_blobs` or `data_blobs` configuration to be relative to the current working directory.
  */
 function normalizeAndValidateModulePaths(
   diagnostics: Diagnostics,
   configPath: string | undefined,
-  field: "wasm_modules" | "text_blobs",
+  field: "wasm_modules" | "text_blobs" | "data_blobs",
   rawMapping: Record<string, string> | undefined
 ): Record<string, string> | undefined {
   if (rawMapping === undefined) {
@@ -392,31 +582,147 @@ function normalizeAndValidateModulePaths(
   return mapping;
 }
 
+/**
+ * Check whether a value has the shape of a route, which can be a string
+ * or an object that looks like {pattern: string, zone_id: string }
+ */
+function isValidRouteValue(item: unknown): boolean {
+  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;
+}
+
+/**
+ * Validate that the field is a route.
+ */
+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, custom_domain, zone_id | zone_name }, but got ${JSON.stringify(
+        value
+      )}.`
+    );
+    return false;
+  }
+  return true;
+};
+
+/**
+ * Validate that the field is an array of routes.
+ */
+const isRouteArray: ValidatorFn = (diagnostics, field, value) => {
+  if (value === undefined) {
+    return true;
+  }
+  if (!Array.isArray(value)) {
+    diagnostics.errors.push(
+      `Expected "${field}" to be an array but got ${JSON.stringify(value)}.`
+    );
+    return false;
+  }
+  const invalidRoutes = [];
+  for (const item of value) {
+    if (!isValidRouteValue(item)) {
+      invalidRoutes.push(item);
+    }
+  }
+  if (invalidRoutes.length > 0) {
+    diagnostics.errors.push(
+      `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
+      )}.`
+    );
+  }
+  return invalidRoutes.length === 0;
+};
+
+function validateRoute(
+  diagnostics: Diagnostics,
+  topLevelEnv: Environment | undefined,
+  rawEnv: RawEnvironment
+): Config["route"] {
+  return inheritable(
+    diagnostics,
+    topLevelEnv,
+    rawEnv,
+    "route",
+    isRoute,
+    undefined
+  );
+}
+
+function validateRoutes(
+  diagnostics: Diagnostics,
+  topLevelEnv: Environment | undefined,
+  rawEnv: RawEnvironment
+): Config["routes"] {
+  return inheritable(
+    diagnostics,
+    topLevelEnv,
+    rawEnv,
+    "routes",
+    all(isRouteArray, isMutuallyExclusiveWith(rawEnv, "route")),
+    undefined
+  );
+}
+
 /**
  * Validate top-level environment configuration and return the normalized values.
  */
 function normalizeAndValidateEnvironment(
   diagnostics: Diagnostics,
-  topLevelEnv: RawEnvironment,
-  deprecatedRules: Environment["rules"] | undefined
+  configPath: string | undefined,
+  topLevelEnv: RawEnvironment
 ): Environment;
 /**
  * Validate the named environment configuration and return the normalized values.
  */
 function normalizeAndValidateEnvironment(
   diagnostics: Diagnostics,
+  configPath: string | undefined,
   rawEnv: RawEnvironment,
-  deprecatedRules: Environment["rules"] | undefined,
   envName: string,
-  config: Config,
+  topLevelEnv: Environment,
+  isLegacyEnv: boolean,
   rawConfig: RawConfig
 ): Environment;
 function normalizeAndValidateEnvironment(
   diagnostics: Diagnostics,
+  configPath: string | undefined,
   rawEnv: RawEnvironment,
-  deprecatedRules: Environment["rules"] | undefined,
   envName = "top level",
-  config?: Config | undefined,
+  topLevelEnv?: Environment | undefined,
+  isLegacyEnv?: boolean,
   rawConfig?: RawConfig | undefined
 ): Environment {
   deprecated(
@@ -433,66 +739,48 @@ 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 = inheritable(
-    diagnostics,
-    config,
-    rawEnv,
-    "route",
-    isString,
-    undefined
-  );
-  const routes = inheritable(
+  const route = validateRoute(diagnostics, topLevelEnv, rawEnv);
+
+  const routes = validateRoutes(diagnostics, topLevelEnv, rawEnv);
+
+  const workers_dev = inheritable(
     diagnostics,
-    config,
+    topLevelEnv,
     rawEnv,
-    "routes",
-    isStringArray,
+    "workers_dev",
+    isBoolean,
     undefined
   );
-  const workers_dev = inheritable(
+
+  const { deprecatedUpload, ...build } = normalizeAndValidateBuild(
     diagnostics,
-    config,
     rawEnv,
-    "workers_dev",
-    isBoolean,
-    !(routes || route)
+    rawEnv.build ?? topLevelEnv?.build ?? {},
+    configPath
   );
 
   const environment: Environment = {
     // Inherited fields
-    account_id: inheritable(
+    account_id: inheritableInLegacyEnvironments(
       diagnostics,
-      config,
+      isLegacyEnv,
+      topLevelEnv,
       rawEnv,
       "account_id",
       isString,
+      undefined,
       undefined
     ),
     compatibility_date: inheritable(
       diagnostics,
-      config,
+      topLevelEnv,
       rawEnv,
       "compatibility_date",
       isString,
@@ -500,7 +788,7 @@ function normalizeAndValidateEnvironment(
     ),
     compatibility_flags: inheritable(
       diagnostics,
-      config,
+      topLevelEnv,
       rawEnv,
       "compatibility_flags",
       isStringArray,
@@ -508,7 +796,7 @@ function normalizeAndValidateEnvironment(
     ),
     jsx_factory: inheritable(
       diagnostics,
-      config,
+      topLevelEnv,
       rawEnv,
       "jsx_factory",
       isString,
@@ -516,25 +804,52 @@ function normalizeAndValidateEnvironment(
     ),
     jsx_fragment: inheritable(
       diagnostics,
-      config,
+      topLevelEnv,
       rawEnv,
       "jsx_fragment",
       isString,
       "React.Fragment"
     ),
+    tsconfig: validateAndNormalizeTsconfig(
+      diagnostics,
+      topLevelEnv,
+      rawEnv,
+      configPath
+    ),
     rules: validateAndNormalizeRules(
       diagnostics,
-      config,
+      topLevelEnv,
       rawEnv,
-      deprecatedRules,
+      deprecatedUpload?.rules,
       envName
     ),
-    name: inheritable(diagnostics, config, rawEnv, "name", isString, undefined),
+    name: inheritableInLegacyEnvironments(
+      diagnostics,
+      isLegacyEnv,
+      topLevelEnv,
+      rawEnv,
+      "name",
+      isValidName,
+      appendEnvName(envName),
+      undefined
+    ),
+    main: normalizeAndValidateMainField(
+      configPath,
+      inheritable(
+        diagnostics,
+        topLevelEnv,
+        rawEnv,
+        "main",
+        isString,
+        undefined
+      ),
+      deprecatedUpload
+    ),
     route,
     routes,
     triggers: inheritable(
       diagnostics,
-      config,
+      topLevelEnv,
       rawEnv,
       "triggers",
       isObjectWith("crons"),
@@ -542,17 +857,18 @@ function normalizeAndValidateEnvironment(
     ),
     usage_model: inheritable(
       diagnostics,
-      config,
+      topLevelEnv,
       rawEnv,
       "usage_model",
       isOneOf("bundled", "unbound"),
       undefined
     ),
+    build,
     workers_dev,
     // Not inherited fields
     vars: notInheritable(
       diagnostics,
-      config,
+      topLevelEnv,
       rawConfig,
       rawEnv,
       envName,
@@ -562,7 +878,7 @@ function normalizeAndValidateEnvironment(
     ),
     durable_objects: notInheritable(
       diagnostics,
-      config,
+      topLevelEnv,
       rawConfig,
       rawEnv,
       envName,
@@ -574,7 +890,7 @@ function normalizeAndValidateEnvironment(
     ),
     kv_namespaces: notInheritable(
       diagnostics,
-      config,
+      topLevelEnv,
       rawConfig,
       rawEnv,
       envName,
@@ -584,7 +900,7 @@ function normalizeAndValidateEnvironment(
     ),
     r2_buckets: notInheritable(
       diagnostics,
-      config,
+      topLevelEnv,
       rawConfig,
       rawEnv,
       envName,
@@ -592,9 +908,19 @@ function normalizeAndValidateEnvironment(
       validateBindingArray(envName, validateR2Binding),
       []
     ),
+    services: notInheritable(
+      diagnostics,
+      topLevelEnv,
+      rawConfig,
+      rawEnv,
+      envName,
+      "services",
+      validateBindingArray(envName, validateServiceBinding),
+      []
+    ),
     unsafe: notInheritable(
       diagnostics,
-      config,
+      topLevelEnv,
       rawConfig,
       rawEnv,
       envName,
@@ -605,27 +931,66 @@ function normalizeAndValidateEnvironment(
       }
     ),
     zone_id: rawEnv.zone_id,
+    minify: inheritable(
+      diagnostics,
+      topLevelEnv,
+      rawEnv,
+      "minify",
+      isBoolean,
+      undefined
+    ),
+    node_compat: inheritable(
+      diagnostics,
+      topLevelEnv,
+      rawEnv,
+      "node_compat",
+      isBoolean,
+      undefined
+    ),
   };
 
   return environment;
 }
 
+function validateAndNormalizeTsconfig(
+  diagnostics: Diagnostics,
+  topLevelEnv: Environment | undefined,
+  rawEnv: RawEnvironment,
+  configPath: string | undefined
+) {
+  const tsconfig = inheritable(
+    diagnostics,
+    topLevelEnv,
+    rawEnv,
+    "tsconfig",
+    isString,
+    undefined
+  );
+
+  return configPath && tsconfig
+    ? path.relative(
+        process.cwd(),
+        path.join(path.dirname(configPath), tsconfig)
+      )
+    : tsconfig;
+}
+
 const validateAndNormalizeRules = (
   diagnostics: Diagnostics,
-  config: Config | undefined,
+  topLevelEnv: Environment | undefined,
   rawEnv: RawEnvironment,
   deprecatedRules: Rule[] | undefined,
   envName: string
 ): Rule[] => {
-  if (config === undefined) {
+  if (topLevelEnv === undefined) {
     // Only create errors/warnings for the top-level environment
     if (rawEnv.rules && deprecatedRules) {
       diagnostics.errors.push(
-        `ERROR: You cannot configure both [rules] and [build.upload.rules] in your wrangler.toml. Delete the \`build.upload\` section.`
+        `You cannot configure both [rules] and [build.upload.rules] in your wrangler.toml. Delete the \`build.upload\` section.`
       );
     } else if (deprecatedRules) {
       diagnostics.warnings.push(
-        `DEPRECATION: The \`build.upload.rules\` config field is no longer used, the rules should be specified via the \`rules\` config field. Delete the \`build.upload\` field from the configuration file, and add this:\n` +
+        `Deprecation: The \`build.upload.rules\` config field is no longer used, the rules should be specified via the \`rules\` config field. Delete the \`build.upload\` field from the configuration file, and add this:\n` +
           "```\n" +
           TOML.stringify({ rules: deprecatedRules }) +
           "```"
@@ -635,7 +1000,7 @@ const validateAndNormalizeRules = (
 
   return inheritable(
     diagnostics,
-    config,
+    topLevelEnv,
     rawEnv,
     "rules",
     validateRules(envName),
@@ -671,7 +1036,9 @@ const validateRules =
 
 const validateRule: ValidatorFn = (diagnostics, field, value) => {
   if (typeof value !== "object" || value === null) {
-    diagnostics.errors.push(`ERROR: should be an object.`);
+    diagnostics.errors.push(
+      `"${field}" should be an object but got ${JSON.stringify(value)}.`
+    );
     return false;
   }
   // Rules must have a type string and glob string array, and optionally a fallthrough boolean.
@@ -688,7 +1055,7 @@ const validateRule: ValidatorFn = (diagnostics, field, value) => {
     ])
   ) {
     diagnostics.errors.push(
-      `ERROR: bindings should have a string "type" field, which contains one of "ESModule", "CommonJS", "CompiledWasm", "Text", or "Data".`
+      `bindings should have a string "type" field, which contains one of "ESModule", "CommonJS", "CompiledWasm", "Text", or "Data".`
     );
     isValid = false;
   }
@@ -699,7 +1066,7 @@ const validateRule: ValidatorFn = (diagnostics, field, value) => {
 
   if (!isOptionalProperty(rule, "fallthrough", "boolean")) {
     diagnostics.errors.push(
-      `ERROR: should, optionally, have a boolean "fallthrough" field.`
+      `the field "fallthrough", when present, should be a boolean.`
     );
     isValid = false;
   }
@@ -796,7 +1163,7 @@ const validateBindingsProperty =
           diagnostics.warnings.push(
             `The following bindings are at the top level, but not on "env.${envName}".\n` +
               `This is not what you probably want, since "${field}" configuration is not inherited by environments.\n` +
-              `Please add a binding for each to "${fieldPath}.bindings".` +
+              `Please add a binding for each to "${fieldPath}.bindings":\n` +
               missingBindings.map((name) => `- ${name}`).join("\n")
           );
         }
@@ -805,42 +1172,48 @@ const validateBindingsProperty =
     return isValid;
   };
 
-/**
- * Get the names of the bindings collection in `value`.
- */
-const getBindingNames = (value: unknown): string[] =>
-  ((value as { bindings: { name: string }[] })?.bindings ?? []).map(
-    (binding) => binding.name
-  );
-
 /**
  * Check that the given field is a valid "durable_object" binding object.
  */
 const validateDurableObjectBinding: ValidatorFn = (
   diagnostics,
-  _field,
+  field,
   value
 ) => {
   if (typeof value !== "object" || value === null) {
-    diagnostics.errors.push(`ERROR: should be an object.`);
+    diagnostics.errors.push(
+      `Expected "${field}" to be an object but got ${JSON.stringify(value)}`
+    );
     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(
-      `ERROR: bindings should have a string "name" field.`
-    );
+    diagnostics.errors.push(`binding should have a string "name" field.`);
     isValid = false;
   }
   if (!isRequiredProperty(value, "class_name", "string")) {
-    diagnostics.errors.push(`ERROR: should have a string "class_name" field.`);
+    diagnostics.errors.push(`binding should have a string "class_name" field.`);
     isValid = false;
   }
   if (!isOptionalProperty(value, "script_name", "string")) {
     diagnostics.errors.push(
-      `ERROR: 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;
   }
@@ -853,24 +1226,31 @@ const validateDurableObjectBinding: ValidatorFn = (
  *
  * TODO: further validation of known unsafe bindings.
  */
-const validateUnsafeBinding: ValidatorFn = (diagnostics, _field, value) => {
+const validateUnsafeBinding: ValidatorFn = (diagnostics, field, value) => {
   if (typeof value !== "object" || value === null) {
-    diagnostics.errors.push(`ERROR: should be an object.`);
+    diagnostics.errors.push(
+      `Expected ${field} to be an object but got ${JSON.stringify(value)}.`
+    );
     return false;
   }
 
   let isValid = true;
   // Unsafe bindings must have a name and type.
   if (!isRequiredProperty(value, "name", "string")) {
-    diagnostics.errors.push(`ERROR: should have a string "name" field.`);
+    diagnostics.errors.push(`binding should have a string "name" field.`);
     isValid = false;
   }
   if (isRequiredProperty(value, "type", "string")) {
     const safeBindings = [
       "plain_text",
       "json",
+      "wasm_module",
+      "data_blob",
+      "text_blob",
       "kv_namespace",
       "durable_object_namespace",
+      "r2_bucket",
+      "service",
     ];
 
     if (safeBindings.includes(value.type)) {
@@ -881,7 +1261,7 @@ const validateUnsafeBinding: ValidatorFn = (diagnostics, _field, value) => {
       );
     }
   } else {
-    diagnostics.errors.push(`ERROR: should have a string "type" field.`);
+    diagnostics.errors.push(`binding should have a string "type" field.`);
     isValid = false;
   }
   return isValid;
@@ -981,7 +1361,7 @@ const validateKVBinding: ValidatorFn = (diagnostics, field, value) => {
 const validateR2Binding: ValidatorFn = (diagnostics, field, value) => {
   if (typeof value !== "object" || value === null) {
     diagnostics.errors.push(
-      `"kv_namespaces" bindings should be objects, but got ${JSON.stringify(
+      `"r2_buckets" bindings should be objects, but got ${JSON.stringify(
         value
       )}`
     );
@@ -1015,3 +1395,136 @@ const validateR2Binding: ValidatorFn = (diagnostics, field, value) => {
   }
   return isValid;
 };
+
+/**
+ * Check that bindings whose names might conflict, don't.
+ *
+ * We don't want to have, for example, a KV namespace named "DATA"
+ * and a Durable Object also named "DATA". Then it would be ambiguous
+ * what exactly would live at `env.DATA` (or in the case of service-workers,
+ * the `DATA` global).
+ */
+const validateBindingsHaveUniqueNames = (
+  diagnostics: Diagnostics,
+  {
+    durable_objects,
+    kv_namespaces,
+    r2_buckets,
+    text_blobs,
+    unsafe,
+    vars,
+    wasm_modules,
+    data_blobs,
+  }: Partial<Config>
+): boolean => {
+  let hasDuplicates = false;
+
+  const bindingsGroupedByType = {
+    "Durable Object": getBindingNames(durable_objects),
+    "KV Namespace": getBindingNames(kv_namespaces),
+    "R2 Bucket": getBindingNames(r2_buckets),
+    "Text Blob": getBindingNames(text_blobs),
+    Unsafe: getBindingNames(unsafe),
+    "Environment Variable": getBindingNames(vars),
+    "WASM Module": getBindingNames(wasm_modules),
+    "Data Blob": getBindingNames(data_blobs),
+  } as Record<string, string[]>;
+
+  const bindingsGroupedByName: Record<string, string[]> = {};
+
+  for (const bindingType in bindingsGroupedByType) {
+    const bindingNames = bindingsGroupedByType[bindingType];
+
+    for (const bindingName of bindingNames) {
+      if (!(bindingName in bindingsGroupedByName)) {
+        bindingsGroupedByName[bindingName] = [];
+      }
+
+      bindingsGroupedByName[bindingName].push(bindingType);
+    }
+  }
+
+  for (const bindingName in bindingsGroupedByName) {
+    const bindingTypes = bindingsGroupedByName[bindingName];
+    if (bindingTypes.length < 2) {
+      // there's only one (or zero) binding(s) with this name, which is fine, actually
+      continue;
+    }
+
+    hasDuplicates = true;
+
+    // there's two types of duplicates we want to look for:
+    // - bindings with the same name of the same type (e.g. two Durable Objects both named "OBJ")
+    // - bindings with the same name of different types (a KV namespace and DO both named "DATA")
+
+    const sameType = bindingTypes
+      // filter once to find duplicate binding types
+      .filter((type, i) => bindingTypes.indexOf(type) !== i)
+      // filter twice to only get _unique_ duplicate binding types
+      .filter(
+        (type, i, duplicateBindingTypes) =>
+          duplicateBindingTypes.indexOf(type) === i
+      );
+
+    const differentTypes = bindingTypes.filter(
+      (type, i) => bindingTypes.indexOf(type) === i
+    );
+
+    if (differentTypes.length > 1) {
+      // we have multiple different types using the same name
+      diagnostics.errors.push(
+        `${bindingName} assigned to ${ENGLISH.format(differentTypes)} bindings.`
+      );
+    }
+
+    sameType.forEach((bindingType) => {
+      diagnostics.errors.push(
+        `${bindingName} assigned to multiple ${bindingType} bindings.`
+      );
+    });
+  }
+
+  if (hasDuplicates) {
+    const problem =
+      "Bindings must have unique names, so that they can all be referenced in the worker.";
+    const resolution = "Please change your bindings to have unique names.";
+    diagnostics.errors.push(`${problem}\n${resolution}`);
+  }
+
+  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;
+};