wrangler 0.0.0-e3cab74 → 0.0.0-e3ce82b

package/src/config/index.ts

@@ -1,9 +1,17 @@
 import { findUpSync } from "find-up";
+import { logger } from "../logger";
 import { parseTOML, readFileSync } from "../parse";
 import { normalizeAndValidateConfig } from "./validation";
+import type { CfWorkerInit } from "../worker";
 import type { Config, RawConfig } from "./config";
 
-export type { Config, RawConfig } from "./config";
+export type {
+  Config,
+  RawConfig,
+  ConfigFields,
+  DevConfig,
+  RawDevConfig,
+} from "./config";
 export type {
   Environment,
   RawEnvironment,
@@ -13,7 +21,10 @@ export type {
 /**
  * Get the Wrangler configuration; read it from the give `configPath` if available.
  */
-export function readConfig(configPath?: string): Config {
+export function readConfig(
+  configPath: string | undefined,
+  args: unknown
+): Config {
   let rawConfig: RawConfig = {};
   if (!configPath) {
     configPath = findWranglerToml();
@@ -27,11 +38,12 @@ export function readConfig(configPath?: string): Config {
   // Process the top-level configuration.
   const { config, diagnostics } = normalizeAndValidateConfig(
     rawConfig,
-    configPath
+    configPath,
+    args
   );
 
   if (diagnostics.hasWarnings()) {
-    console.warn(diagnostics.renderWarnings());
+    logger.warn(diagnostics.renderWarnings());
   }
   if (diagnostics.hasErrors()) {
     throw new Error(diagnostics.renderErrors());
@@ -50,3 +62,164 @@ export function findWranglerToml(
   const configPath = findUpSync("wrangler.toml", { cwd: referencePath });
   return configPath;
 }
+
+/**
+ * Print all the bindings a worker using a given config would have access to
+ */
+export function printBindings(bindings: CfWorkerInit["bindings"]) {
+  const truncate = (item: string | Record<string, unknown>) => {
+    const s = typeof item === "string" ? item : JSON.stringify(item);
+    const maxLength = 40;
+    if (s.length < maxLength) {
+      return s;
+    }
+
+    return `${s.substring(0, maxLength - 3)}...`;
+  };
+
+  const output: { type: string; entries: { key: string; value: string }[] }[] =
+    [];
+
+  const {
+    data_blobs,
+    durable_objects,
+    kv_namespaces,
+    r2_buckets,
+    services,
+    text_blobs,
+    unsafe,
+    vars,
+    wasm_modules,
+  } = bindings;
+
+  if (data_blobs !== undefined && Object.keys(data_blobs).length > 0) {
+    output.push({
+      type: "Data Blobs",
+      entries: Object.entries(data_blobs).map(([key, value]) => ({
+        key,
+        value: truncate(value),
+      })),
+    });
+  }
+
+  if (durable_objects !== undefined && durable_objects.bindings.length > 0) {
+    output.push({
+      type: "Durable Objects",
+      entries: durable_objects.bindings.map(
+        ({ name, class_name, script_name, environment }) => {
+          let value = class_name;
+          if (script_name) {
+            value += ` (defined in ${script_name})`;
+          }
+          if (environment) {
+            value += ` - ${environment}`;
+          }
+
+          return {
+            key: name,
+            value,
+          };
+        }
+      ),
+    });
+  }
+
+  if (kv_namespaces !== undefined && kv_namespaces.length > 0) {
+    output.push({
+      type: "KV Namespaces",
+      entries: kv_namespaces.map(({ binding, id }) => {
+        return {
+          key: binding,
+          value: id,
+        };
+      }),
+    });
+  }
+
+  if (r2_buckets !== undefined && r2_buckets.length > 0) {
+    output.push({
+      type: "R2 Buckets",
+      entries: r2_buckets.map(({ binding, bucket_name }) => {
+        return {
+          key: binding,
+          value: bucket_name,
+        };
+      }),
+    });
+  }
+
+  if (services !== undefined && services.length > 0) {
+    output.push({
+      type: "Services",
+      entries: services.map(({ binding, service, environment }) => {
+        let value = service;
+        if (environment) {
+          value += ` - ${environment}`;
+        }
+
+        return {
+          key: binding,
+          value,
+        };
+      }),
+    });
+  }
+
+  if (text_blobs !== undefined && Object.keys(text_blobs).length > 0) {
+    output.push({
+      type: "Text Blobs",
+      entries: Object.entries(text_blobs).map(([key, value]) => ({
+        key,
+        value: truncate(value),
+      })),
+    });
+  }
+
+  if (unsafe !== undefined && unsafe.length > 0) {
+    output.push({
+      type: "Unsafe",
+      entries: unsafe.map(({ name, type }) => ({
+        key: type,
+        value: name,
+      })),
+    });
+  }
+
+  if (vars !== undefined && Object.keys(vars).length > 0) {
+    output.push({
+      type: "Vars",
+      entries: Object.entries(vars).map(([key, value]) => ({
+        key,
+        value: `"${truncate(`${value}`)}"`,
+      })),
+    });
+  }
+
+  if (wasm_modules !== undefined && Object.keys(wasm_modules).length > 0) {
+    output.push({
+      type: "Wasm Modules",
+      entries: Object.entries(wasm_modules).map(([key, value]) => ({
+        key,
+        value: truncate(value),
+      })),
+    });
+  }
+
+  if (output.length === 0) {
+    return;
+  }
+
+  const message = [
+    `Your worker has access to the following bindings:`,
+    ...output
+      .map((bindingGroup) => {
+        return [
+          `- ${bindingGroup.type}:`,
+          bindingGroup.entries.map(({ key, value }) => `  - ${key}: ${value}`),
+        ];
+      })
+      .flat(2),
+  ].join("\n");
+
+  logger.log(message);
+}

package/src/config/validation-helpers.ts

@@ -1,11 +1,11 @@
-import type { Config, RawConfig } from "./config";
+import type { RawConfig } from "./config";
 import type { Diagnostics } from "./diagnostics";
 import type { Environment, RawEnvironment } from "./environment";
 
 /**
  *  Mark a field as deprecated.
  *
- * This function will add a diagnostics warning if the deprecated field is found in the `rawEnv`.
+ * This function will add a diagnostics warning if the deprecated field is found in the `rawEnv` (or an error if it's also a breaking deprecation)
  * The `fieldPath` is a dot separated property path, e.g. `"build.upload.format"`.
  */
 export function deprecated<T extends object>(
@@ -13,11 +13,16 @@ export function deprecated<T extends object>(
   config: T,
   fieldPath: DeepKeyOf<T>,
   message: string,
-  remove: boolean
+  remove: boolean,
+  title = "Deprecation",
+  type: "warning" | "error" = "warning"
 ): void {
+  const BOLD = "\x1b[1m";
+  const NORMAL = "\x1b[0m";
+  const diagnosticMessage = `${BOLD}${title}${NORMAL}: "${fieldPath}":\n${message}`;
   const result = unwindPropertyPath(config, fieldPath);
   if (result !== undefined && result.field in result.container) {
-    diagnostics.warnings.push(`DEPRECATION: "${fieldPath}":\n${message}`);
+    diagnostics[`${type}s`].push(diagnosticMessage);
     if (remove) {
       delete (result.container as Record<string, unknown>)[result.field];
     }
@@ -51,14 +56,82 @@ export function experimental<T extends object>(
  */
 export function inheritable<K extends keyof Environment>(
   diagnostics: Diagnostics,
-  config: Config | undefined,
+  topLevelEnv: Environment | undefined,
   rawEnv: RawEnvironment,
   field: K,
   validate: ValidatorFn,
+  defaultValue: Environment[K],
+  transformFn: TransformFn<Environment[K]> = (v) => v
+): Environment[K] {
+  validate(diagnostics, field, rawEnv[field], topLevelEnv);
+  return (
+    (rawEnv[field] as Environment[K]) ??
+    transformFn(topLevelEnv?.[field]) ??
+    defaultValue
+  );
+}
+
+/**
+ * Get an inheritable environment field, but only if we are in legacy environments
+ */
+export function inheritableInLegacyEnvironments<K extends keyof Environment>(
+  diagnostics: Diagnostics,
+  isLegacyEnv: boolean | undefined,
+  topLevelEnv: Environment | undefined,
+  rawEnv: RawEnvironment,
+  field: K,
+  validate: ValidatorFn,
+  transformFn: TransformFn<Environment[K]> = (v) => v,
   defaultValue: Environment[K]
 ): Environment[K] {
-  validate(diagnostics, field, rawEnv[field], config);
-  return (rawEnv[field] as Environment[K]) ?? config?.[field] ?? defaultValue;
+  return topLevelEnv === undefined || isLegacyEnv === true
+    ? inheritable(
+        diagnostics,
+        topLevelEnv,
+        rawEnv,
+        field,
+        validate,
+        defaultValue,
+        transformFn
+      )
+    : notAllowedInNamedServiceEnvironment(
+        diagnostics,
+        topLevelEnv,
+        rawEnv,
+        field
+      );
+}
+
+/**
+ * Type of function that is used to transform an inheritable environment field.
+ */
+type TransformFn<T> = (fieldValue: T | undefined) => T | undefined;
+
+/**
+ * Transform an environment field by appending current environment name to it.
+ */
+export const appendEnvName =
+  (envName: string): TransformFn<string | undefined> =>
+  (fieldValue) =>
+    fieldValue ? `${fieldValue}-${envName}` : undefined;
+
+/**
+ * Log an error if this named environment is trying to override the value in the top-level
+ * environment, which is not allow for this field.
+ */
+function notAllowedInNamedServiceEnvironment<K extends keyof Environment>(
+  diagnostics: Diagnostics,
+  topLevelEnv: Environment,
+  rawEnv: RawEnvironment,
+  field: K
+): Environment[K] {
+  if (field in rawEnv) {
+    diagnostics.errors.push(
+      `The "${field}" field is not allowed in named service environments.\n` +
+        `Please remove the field from this environment.`
+    );
+  }
+  return topLevelEnv[field];
 }
 
 /**
@@ -69,7 +142,7 @@ export function inheritable<K extends keyof Environment>(
  */
 export function notInheritable<K extends keyof Environment>(
   diagnostics: Diagnostics,
-  config: Config | undefined,
+  topLevelEnv: Environment | undefined,
   rawConfig: RawConfig | undefined,
   rawEnv: RawEnvironment,
   envName: string,
@@ -78,7 +151,7 @@ export function notInheritable<K extends keyof Environment>(
   defaultValue: Environment[K]
 ): Environment[K] {
   if (rawEnv[field] !== undefined) {
-    validate(diagnostics, field, rawEnv[field], config);
+    validate(diagnostics, field, rawEnv[field], topLevelEnv);
   } else {
     if (rawConfig?.[field] !== undefined) {
       diagnostics.warnings.push(
@@ -136,7 +209,7 @@ export type ValidatorFn = (
   diagnostics: Diagnostics,
   field: string,
   value: unknown,
-  config: Config | undefined
+  topLevelEnv: Environment | undefined
 ) => boolean;
 
 /**
@@ -145,7 +218,7 @@ export type ValidatorFn = (
 export const isString: ValidatorFn = (diagnostics, field, value) => {
   if (value !== undefined && typeof value !== "string") {
     diagnostics.errors.push(
-      `Expected "${field}" field to be a string but got ${JSON.stringify(
+      `Expected "${field}" to be of type string but got ${JSON.stringify(
         value
       )}.`
     );
@@ -154,6 +227,25 @@ export const isString: ValidatorFn = (diagnostics, field, value) => {
   return true;
 };
 
+/**
+ * Validate that the `name` field is compliant with EWC constraints.
+ */
+export const isValidName: ValidatorFn = (diagnostics, field, value) => {
+  if (
+    (typeof value === "string" && /^$|^[a-z0-9_ ][a-z0-9-_ ]*$/.test(value)) ||
+    value === undefined
+  ) {
+    return true;
+  } else {
+    diagnostics.errors.push(
+      `Expected "${field}" to be of type string, alphanumeric and lowercase with dashes only but got ${JSON.stringify(
+        value
+      )}.`
+    );
+    return false;
+  }
+};
+
 /**
  * Validate that the field is an array of strings.
  */
@@ -163,7 +255,7 @@ export const isStringArray: ValidatorFn = (diagnostics, field, value) => {
     (!Array.isArray(value) || value.some((item) => typeof item !== "string"))
   ) {
     diagnostics.errors.push(
-      `Expected "${field}" field to be an array of strings but got ${JSON.stringify(
+      `Expected "${field}" to be of type string array but got ${JSON.stringify(
         value
       )}.`
     );
@@ -185,12 +277,21 @@ export const isObjectWith =
         !properties.every((prop) => prop in value))
     ) {
       diagnostics.errors.push(
-        `Expected "${field}" field to be an object containing properties ${properties} but got ${JSON.stringify(
+        `Expected "${field}" to be of type object, containing only properties ${properties}, but got ${JSON.stringify(
           value
         )}.`
       );
       return false;
     }
+    // it's an object with the field as desired,
+    // but let's also check for unexpected fields
+    if (value !== undefined) {
+      const restFields = Object.keys(value).filter(
+        (key) => !properties.includes(key)
+      );
+      validateAdditionalProperties(diagnostics, field, restFields, []);
+    }
+
     return true;
   };
 
@@ -202,22 +303,70 @@ export const isOneOf =
   (diagnostics, field, value) => {
     if (value !== undefined && !choices.some((choice) => value === choice)) {
       diagnostics.errors.push(
-        `Expected "${field}" field to be on of ${choices} but got ${JSON.stringify(
-          value
-        )}.`
+        `Expected "${field}" field to be one of ${JSON.stringify(
+          choices
+        )} but got ${JSON.stringify(value)}.`
       );
       return false;
     }
     return true;
   };
 
+/**
+ * Aggregate multiple validator functions
+ */
+export const all = (...validations: ValidatorFn[]): ValidatorFn => {
+  return (diagnostics, field, value, config) => {
+    let passedValidations = true;
+
+    for (const validate of validations) {
+      if (!validate(diagnostics, field, value, config)) {
+        passedValidations = false;
+      }
+    }
+
+    return passedValidations;
+  };
+};
+
+/**
+ * Check that the field is mutually exclusive with a list of other fields.
+ *
+ * @param container the container of the fields to check against.
+ * @param fields the names of the fields to check against.
+ */
+export const isMutuallyExclusiveWith = <T extends RawEnvironment | RawConfig>(
+  container: T,
+  ...fields: (keyof T)[]
+): ValidatorFn => {
+  return (diagnostics, field, value) => {
+    if (value === undefined) {
+      return true;
+    }
+
+    for (const exclusiveWith of fields) {
+      if (container[exclusiveWith] !== undefined) {
+        diagnostics.errors.push(
+          `Expected exactly one of the following fields ${JSON.stringify([
+            field,
+            ...fields,
+          ])}.`
+        );
+        return false;
+      }
+    }
+
+    return true;
+  };
+};
+
 /**
  * Validate that the field is a boolean.
  */
 export const isBoolean: ValidatorFn = (diagnostics, field, value) => {
   if (value !== undefined && typeof value !== "boolean") {
     diagnostics.errors.push(
-      `Expected "${field}" field to be a boolean but got ${JSON.stringify(
+      `Expected "${field}" to be of type boolean but got ${JSON.stringify(
         value
       )}.`
     );
@@ -234,21 +383,28 @@ export const validateRequiredProperty = (
   container: string,
   key: string,
   value: unknown,
-  type: string
+  type: string,
+  choices?: unknown[]
 ): boolean => {
   if (container) {
     container += ".";
   }
   if (value === undefined) {
-    diagnostics.errors.push(`ERROR: "${container}${key}" is a required field.`);
+    diagnostics.errors.push(`"${container}${key}" is a required field.`);
     return false;
   } else if (typeof value !== type) {
     diagnostics.errors.push(
-      `ERROR: "${container}${key}" should be of type ${type} but got ${JSON.stringify(
+      `Expected "${container}${key}" to be of type ${type} but got ${JSON.stringify(
         value
       )}.`
     );
     return false;
+  } else if (choices) {
+    if (
+      !isOneOf(...choices)(diagnostics, `${container}${key}`, value, undefined)
+    ) {
+      return false;
+    }
   }
   return true;
 };
@@ -261,10 +417,18 @@ export const validateOptionalProperty = (
   container: string,
   key: string,
   value: unknown,
-  type: string
+  type: string,
+  choices?: unknown[]
 ): boolean => {
   if (value !== undefined) {
-    return validateRequiredProperty(diagnostics, container, key, value, type);
+    return validateRequiredProperty(
+      diagnostics,
+      container,
+      key,
+      value,
+      type,
+      choices
+    );
   }
   return true;
 };
@@ -281,7 +445,7 @@ export const validateTypedArray = (
   let isValid = true;
   if (!Array.isArray(value)) {
     diagnostics.errors.push(
-      `"${container}" should be an array of ${type}s but got ${JSON.stringify(
+      `Expected "${container}" to be an array of ${type}s but got ${JSON.stringify(
         value
       )}`
     );
@@ -368,3 +532,53 @@ export const validateAdditionalProperties = (
   }
   return true;
 };
+
+/**
+ * Get the names of the bindings collection in `value`.
+ *
+ * Will return an empty array if it doesn't understand the value
+ * passed in, so another form of validation should be
+ * performed externally.
+ */
+export const getBindingNames = (value: unknown): string[] => {
+  if (typeof value !== "object" || value === null) {
+    return [];
+  }
+
+  if (isBindingList(value)) {
+    return value.bindings.map(({ name }) => name);
+  } else if (isNamespaceList(value)) {
+    return value.map(({ binding }) => binding);
+  } else if (isRecord(value)) {
+    return Object.keys(value);
+  } else {
+    return [];
+  }
+};
+
+const isBindingList = (
+  value: unknown
+): value is {
+  bindings: {
+    name: string;
+  }[];
+} =>
+  isRecord(value) &&
+  "bindings" in value &&
+  Array.isArray(value.bindings) &&
+  value.bindings.every(
+    (binding) =>
+      isRecord(binding) && "name" in binding && typeof binding.name === "string"
+  );
+
+const isNamespaceList = (value: unknown): value is { binding: string }[] =>
+  Array.isArray(value) &&
+  value.every(
+    (entry) =>
+      isRecord(entry) && "binding" in entry && typeof entry.binding === "string"
+  );
+
+const isRecord = (
+  value: unknown
+): value is Record<string | number | symbol, unknown> =>
+  typeof value === "object" && value !== null && !Array.isArray(value);