wrangler 0.0.0-e2f9bb2 → 0.0.0-e322475

package/src/config/environment.ts

@@ -8,6 +8,24 @@ export interface Environment
   extends EnvironmentInheritable,
     EnvironmentNonInheritable {}
 
+export type SimpleRoute = string;
+export type ZoneIdRoute = {
+  pattern: string;
+  zone_id: string;
+  custom_domain?: boolean;
+};
+export type ZoneNameRoute = {
+  pattern: string;
+  zone_name: string;
+  custom_domain?: boolean;
+};
+export type CustomDomainRoute = { pattern: string; custom_domain: boolean };
+export type Route =
+  | SimpleRoute
+  | ZoneIdRoute
+  | ZoneNameRoute
+  | CustomDomainRoute;
+
 /**
  * The `EnvironmentInheritable` interface declares all the configuration fields for an environment
  * that can be inherited (and overridden) from the top-level environment.
@@ -74,13 +92,7 @@ interface EnvironmentInheritable {
    *
    * @inheritable
    */
-  routes:
-    | (
-        | string
-        | { pattern: string; zone_id: string }
-        | { pattern: string; zone_name: string }
-      )[]
-    | undefined;
+  routes: Route[] | undefined;
 
   /**
    * A route that your worker should be published to. Literally
@@ -91,13 +103,7 @@ interface EnvironmentInheritable {
    *
    * @inheritable
    */
-  route:
-    | (
-        | string
-        | { pattern: string; zone_id: string }
-        | { pattern: string; zone_name: string }
-      )
-    | undefined;
+  route: Route | undefined;
 
   /**
    * Path to a custom tsconfig
@@ -169,7 +175,7 @@ interface EnvironmentInheritable {
     /** The directory in which the command is executed. */
     cwd?: string;
     /** The directory to watch for changes while using wrangler dev, defaults to the current working directory */
-    watch_dir?: string;
+    watch_dir?: string | string[];
     /**
      * Deprecated field previously used to configure the build and upload of the script.
      * @deprecated
@@ -236,6 +242,8 @@ interface EnvironmentNonInheritable {
       class_name: string;
       /** The script where the Durable Object is defined (if it's external to this worker) */
       script_name?: string;
+      /** The service environment of the script_name to bind to */
+      environment?: string;
     }[];
   };
 
@@ -279,6 +287,24 @@ interface EnvironmentNonInheritable {
     preview_bucket_name?: string;
   }[];
 
+  /**
+   * Specifies service bindings (worker-to-worker) that are bound to this Worker environment.
+   *
+   * NOTE: This field is not automatically inherited from the top level environment,
+   * and so must be specified in every named environment.
+   *
+   * @default `[]`
+   * @nonInheritable
+   */
+  services: {
+    /** The binding name used to refer to the bound service. */
+    binding: string;
+    /** The name of the service. */
+    service: string;
+    /** The environment of the service (e.g. production, staging, etc). */
+    environment?: string;
+  }[];
+
   /**
    * "Unsafe" tables for features that aren't directly supported by wrangler.
    *

package/src/config/index.ts

@@ -2,6 +2,7 @@ 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 {
@@ -61,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

@@ -277,12 +277,21 @@ export const isObjectWith =
         !properties.every((prop) => prop in value))
     ) {
       diagnostics.errors.push(
-        `Expected "${field}" to be of type 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;
   };