wrangler 0.0.0-e88a54e → 0.0.0-e95e5a0

package/src/config/validation.ts

@@ -22,6 +22,9 @@ import {
   all,
   isMutuallyExclusiveWith,
   inheritableInLegacyEnvironments,
+  appendEnvName,
+  getBindingNames,
+  isValidName,
 } from "./validation-helpers";
 import type { Config, DevConfig, RawConfig, RawDevConfig } from "./config";
 import type {
@@ -32,6 +35,8 @@ import type {
 } from "./environment";
 import type { ValidatorFn } from "./validation-helpers";
 
+const ENGLISH = new Intl.ListFormat("en");
+
 /**
  * Validate the given `rawConfig` object that was loaded from `configPath`.
  *
@@ -43,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;
@@ -57,26 +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"
   );
 
   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"
   );
 
   validateOptionalProperty(
@@ -87,8 +94,34 @@ export function normalizeAndValidateConfig(
     "boolean"
   );
 
+  validateOptionalProperty(
+    diagnostics,
+    "",
+    "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,
@@ -96,13 +129,16 @@ export function normalizeAndValidateConfig(
     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,
@@ -114,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)
@@ -147,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,
@@ -160,13 +213,21 @@ export function normalizeAndValidateConfig(
       "text_blobs",
       rawConfig.text_blobs
     ),
+    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 };
@@ -389,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) {
@@ -431,6 +557,102 @@ 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.
  */
@@ -496,29 +718,17 @@ function normalizeAndValidateEnvironment(
 
   experimental(diagnostics, rawEnv, "unsafe");
 
-  const route = inheritable(
-    diagnostics,
-    topLevelEnv,
-    rawEnv,
-    "route",
-    isString,
-    undefined
-  );
-  const routes = inheritable(
-    diagnostics,
-    topLevelEnv,
-    rawEnv,
-    "routes",
-    all(isStringArray, isMutuallyExclusiveWith(rawEnv, "route")),
-    undefined
-  );
+  const route = validateRoute(diagnostics, topLevelEnv, rawEnv);
+
+  const routes = validateRoutes(diagnostics, topLevelEnv, rawEnv);
+
   const workers_dev = inheritable(
     diagnostics,
     topLevelEnv,
     rawEnv,
     "workers_dev",
     isBoolean,
-    !(routes || route)
+    undefined
   );
 
   const { deprecatedUpload, ...build } = normalizeAndValidateBuild(
@@ -530,12 +740,14 @@ function normalizeAndValidateEnvironment(
 
   const environment: Environment = {
     // Inherited fields
-    account_id: inheritable(
+    account_id: inheritableInLegacyEnvironments(
       diagnostics,
+      isLegacyEnv,
       topLevelEnv,
       rawEnv,
       "account_id",
       isString,
+      undefined,
       undefined
     ),
     compatibility_date: inheritable(
@@ -570,6 +782,12 @@ function normalizeAndValidateEnvironment(
       isString,
       "React.Fragment"
     ),
+    tsconfig: validateAndNormalizeTsconfig(
+      diagnostics,
+      topLevelEnv,
+      rawEnv,
+      configPath
+    ),
     rules: validateAndNormalizeRules(
       diagnostics,
       topLevelEnv,
@@ -583,7 +801,8 @@ function normalizeAndValidateEnvironment(
       topLevelEnv,
       rawEnv,
       "name",
-      isString,
+      isValidName,
+      appendEnvName(envName),
       undefined
     ),
     main: normalizeAndValidateMainField(
@@ -674,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,
@@ -694,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 }) +
           "```"
@@ -867,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")
           );
         }
@@ -876,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.
  */
@@ -1054,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
       )}`
     );
@@ -1088,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;
+};

package/src/config-cache.ts

@@ -0,0 +1,45 @@
+import { mkdirSync, readFileSync, rmSync, writeFileSync } from "fs";
+import { dirname, join } from "path";
+
+let cacheMessageShown = false;
+
+const cacheFolder = "node_modules/.cache/wrangler";
+
+const showCacheMessage = () => {
+  if (!cacheMessageShown) {
+    console.log(
+      `Using cached values in '${cacheFolder}'. This is used as a temporary store to improve the developer experience for some commands. It may be purged at any time. It doesn't contain any sensitive information, but it should not be commited into source control.`
+    );
+    cacheMessageShown = true;
+  }
+};
+
+export const getConfigCache = <T>(fileName: string): Partial<T> => {
+  try {
+    const configCacheLocation = join(cacheFolder, fileName);
+    const configCache = JSON.parse(readFileSync(configCacheLocation, "utf-8"));
+    showCacheMessage();
+    return configCache;
+  } catch {
+    return {};
+  }
+};
+
+export const saveToConfigCache = <T>(
+  fileName: string,
+  newValues: Partial<T>
+) => {
+  const configCacheLocation = join(cacheFolder, fileName);
+  const existingValues = getConfigCache(fileName);
+
+  mkdirSync(dirname(configCacheLocation), { recursive: true });
+  writeFileSync(
+    configCacheLocation,
+    JSON.stringify({ ...existingValues, ...newValues }, null, 2)
+  );
+  showCacheMessage();
+};
+
+export const purgeConfigCaches = () => {
+  rmSync(cacheFolder, { recursive: true, force: true });
+};