wrangler 0.0.0-e95bea2 → 0.0.0-e95e5a0

package/src/config/validation-helpers.ts

@@ -1,4 +1,4 @@
-import type { Config, RawConfig } from "./config";
+import type { RawConfig } from "./config";
 import type { Diagnostics } from "./diagnostics";
 import type { Environment, RawEnvironment } from "./environment";
 
@@ -14,13 +14,15 @@ export function deprecated<T extends object>(
   fieldPath: DeepKeyOf<T>,
   message: string,
   remove: boolean,
-  breaking = false
+  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) {
-    (breaking ? diagnostics.errors : diagnostics.warnings).push(
-      `DEPRECATION: "${fieldPath}":\n${message}`
-    );
+    diagnostics[`${type}s`].push(diagnosticMessage);
     if (remove) {
       delete (result.container as Record<string, unknown>)[result.field];
     }
@@ -54,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];
 }
 
 /**
@@ -72,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,
@@ -81,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(
@@ -139,7 +209,7 @@ export type ValidatorFn = (
   diagnostics: Diagnostics,
   field: string,
   value: unknown,
-  config: Config | undefined
+  topLevelEnv: Environment | undefined
 ) => boolean;
 
 /**
@@ -148,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
       )}.`
     );
@@ -157,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.
  */
@@ -166,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
       )}.`
     );
@@ -188,7 +277,7 @@ 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 properties ${properties}, but got ${JSON.stringify(
           value
         )}.`
       );
@@ -214,13 +303,61 @@ export const isOneOf =
     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
       )}.`
     );
@@ -386,3 +523,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);