wrangler 0.0.0-e29a241 → 0.0.0-e2f9bb2

package/src/config/validation.ts

@@ -22,17 +22,21 @@ import {
   all,
   isMutuallyExclusiveWith,
   inheritableInLegacyEnvironments,
+  appendEnvName,
+  getBindingNames,
+  isValidName,
 } from "./validation-helpers";
+import type { Config, DevConfig, RawConfig, RawDevConfig } from "./config";
 import type {
-  Config,
+  RawEnvironment,
   DeprecatedUpload,
-  DevConfig,
-  RawConfig,
-  RawDevConfig,
-} from "./config";
-import type { RawEnvironment, Environment, Rule } from "./environment";
+  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`.
  *
@@ -44,7 +48,7 @@ import type { ValidatorFn } from "./validation-helpers";
 export function normalizeAndValidateConfig(
   rawConfig: RawConfig,
   configPath: string | undefined,
-  envName: string | undefined
+  args: unknown
 ): {
   config: Config;
   diagnostics: Diagnostics;
@@ -58,65 +62,87 @@ 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"
   );
 
   deprecated(
     diagnostics,
     rawConfig,
-    `site.entry-point`,
-    `The \`site.entry-point\` config field is no longer used.\nThe entry-point should be specified via the command line or the \`main\` config field.`,
-    false,
-    true
+    "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"
   );
 
-  const { deprecatedUpload, ...build } = normalizeAndValidateBuild(
+  validateOptionalProperty(
     diagnostics,
-    rawConfig,
-    rawConfig.build ?? {},
-    configPath
+    "",
+    "legacy_env",
+    rawConfig.legacy_env,
+    "boolean"
   );
 
   validateOptionalProperty(
     diagnostics,
     "",
-    "legacy_env",
-    rawConfig.legacy_env,
+    "minify",
+    rawConfig.minify,
+    "boolean"
+  );
+
+  validateOptionalProperty(
+    diagnostics,
+    "",
+    "node_compat",
+    rawConfig.node_compat,
     "boolean"
   );
 
   // TODO: set the default to false to turn on service environments as the default
-  const isLegacyEnv = rawConfig.legacy_env ?? true;
+  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,
-    deprecatedUpload
+    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) {
-      const envDiagnostics = new Diagnostics(
-        `"env.${envName}" environment configuration`
-      );
       activeEnv = normalizeAndValidateEnvironment(
         envDiagnostics,
         configPath,
         rawEnv,
-        deprecatedUpload,
         envName,
         topLevelEnv,
         isLegacyEnv,
@@ -124,6 +150,18 @@ export function normalizeAndValidateConfig(
       );
       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)
@@ -157,7 +195,12 @@ export function normalizeAndValidateConfig(
       diagnostics,
       rawConfig.migrations ?? []
     ),
-    site: normalizeAndValidateSite(diagnostics, rawConfig.site),
+    site: normalizeAndValidateSite(
+      diagnostics,
+      configPath,
+      rawConfig,
+      activeEnv.main
+    ),
     wasm_modules: normalizeAndValidateModulePaths(
       diagnostics,
       configPath,
@@ -170,14 +213,21 @@ export function normalizeAndValidateConfig(
       "text_blobs",
       rawConfig.text_blobs
     ),
-    build,
+    data_blobs: normalizeAndValidateModulePaths(
+      diagnostics,
+      configPath,
+      "data_blobs",
+      rawConfig.data_blobs
+    ),
   };
 
+  validateBindingsHaveUniqueNames(diagnostics, config);
+
   validateAdditionalProperties(
     diagnostics,
     "top-level",
     Object.keys(rawConfig),
-    [...Object.keys(config), "env", "miniflare"]
+    [...Object.keys(config), "env"]
   );
 
   return { config, diagnostics };
@@ -188,7 +238,7 @@ export function normalizeAndValidateConfig(
  */
 function normalizeAndValidateBuild(
   diagnostics: Diagnostics,
-  rawConfig: RawConfig,
+  rawEnv: RawEnvironment,
   rawBuild: Config["build"],
   configPath: string | undefined
 ): Config["build"] & { deprecatedUpload: DeprecatedUpload } {
@@ -208,13 +258,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` +
@@ -223,7 +273,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` +
@@ -238,7 +288,7 @@ 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
@@ -280,7 +330,7 @@ function normalizeAndValidateMainField(
       const directory = path.resolve(configDir);
       return path.resolve(directory, rawMain);
     } else {
-      return;
+      return rawMain;
     }
   } else if (deprecatedUpload?.main !== undefined) {
     const directory = path.resolve(
@@ -400,26 +450,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, 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");
-    return { bucket, include, exclude };
+    validateOptionalProperty(
+      diagnostics,
+      "site",
+      "entry-point",
+      rawConfig.site["entry-point"],
+      "string"
+    );
+
+    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) {
@@ -442,14 +557,109 @@ 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 {
+  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))
+  );
+}
+
+/**
+ * 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, 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, 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,
   configPath: string | undefined,
-  topLevelEnv: RawEnvironment,
-  deprecatedUpload: DeprecatedUpload | undefined
+  topLevelEnv: RawEnvironment
 ): Environment;
 /**
  * Validate the named environment configuration and return the normalized values.
@@ -458,7 +668,6 @@ function normalizeAndValidateEnvironment(
   diagnostics: Diagnostics,
   configPath: string | undefined,
   rawEnv: RawEnvironment,
-  deprecatedUpload: DeprecatedUpload | undefined,
   envName: string,
   topLevelEnv: Environment,
   isLegacyEnv: boolean,
@@ -468,7 +677,6 @@ function normalizeAndValidateEnvironment(
   diagnostics: Diagnostics,
   configPath: string | undefined,
   rawEnv: RawEnvironment,
-  deprecatedUpload: DeprecatedUpload | undefined,
   envName = "top level",
   topLevelEnv?: Environment | undefined,
   isLegacyEnv?: boolean,
@@ -510,39 +718,36 @@ function normalizeAndValidateEnvironment(
 
   experimental(diagnostics, rawEnv, "unsafe");
 
-  const route = inheritable(
-    diagnostics,
-    topLevelEnv,
-    rawEnv,
-    "route",
-    isString,
-    undefined
-  );
-  const routes = inheritable(
+  const route = validateRoute(diagnostics, topLevelEnv, rawEnv);
+
+  const routes = validateRoutes(diagnostics, topLevelEnv, rawEnv);
+
+  const workers_dev = inheritable(
     diagnostics,
     topLevelEnv,
     rawEnv,
-    "routes",
-    all(isStringArray, isMutuallyExclusiveWith(rawEnv, "route")),
+    "workers_dev",
+    isBoolean,
     undefined
   );
-  const workers_dev = inheritable(
+
+  const { deprecatedUpload, ...build } = normalizeAndValidateBuild(
     diagnostics,
-    topLevelEnv,
     rawEnv,
-    "workers_dev",
-    isBoolean,
-    !(routes || route)
+    rawEnv.build ?? topLevelEnv?.build ?? {},
+    configPath
   );
 
   const environment: Environment = {
     // Inherited fields
-    account_id: inheritable(
+    account_id: inheritableInLegacyEnvironments(
       diagnostics,
+      isLegacyEnv,
       topLevelEnv,
       rawEnv,
       "account_id",
       isString,
+      undefined,
       undefined
     ),
     compatibility_date: inheritable(
@@ -577,6 +782,12 @@ function normalizeAndValidateEnvironment(
       isString,
       "React.Fragment"
     ),
+    tsconfig: validateAndNormalizeTsconfig(
+      diagnostics,
+      topLevelEnv,
+      rawEnv,
+      configPath
+    ),
     rules: validateAndNormalizeRules(
       diagnostics,
       topLevelEnv,
@@ -590,7 +801,8 @@ function normalizeAndValidateEnvironment(
       topLevelEnv,
       rawEnv,
       "name",
-      isString,
+      isValidName,
+      appendEnvName(envName),
       undefined
     ),
     main: normalizeAndValidateMainField(
@@ -623,6 +835,7 @@ function normalizeAndValidateEnvironment(
       isOneOf("bundled", "unbound"),
       undefined
     ),
+    build,
     workers_dev,
     // Not inherited fields
     vars: notInheritable(
@@ -680,11 +893,36 @@ function normalizeAndValidateEnvironment(
       }
     ),
     zone_id: rawEnv.zone_id,
+    minify: rawEnv.minify,
+    node_compat: rawEnv.node_compat,
   };
 
   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,
   topLevelEnv: Environment | undefined,
@@ -700,7 +938,7 @@ const validateAndNormalizeRules = (
       );
     } 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 }) +
           "```"
@@ -873,7 +1111,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")
           );
         }
@@ -882,14 +1120,6 @@ 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.
  */
@@ -1060,7 +1290,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
       )}`
     );
@@ -1094,3 +1324,101 @@ 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;
+};