wrangler 0.0.0-e2f9bb2 → 0.0.0-e322475

package/src/config/validation.ts

@@ -94,22 +94,6 @@ 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 =
     (args as { "legacy-env": boolean | undefined })["legacy-env"] ??
@@ -193,7 +177,8 @@ export function normalizeAndValidateConfig(
     dev: normalizeAndValidateDev(diagnostics, rawConfig.dev ?? {}),
     migrations: normalizeAndValidateMigrations(
       diagnostics,
-      rawConfig.migrations ?? []
+      rawConfig.migrations ?? [],
+      activeEnv.durable_objects
     ),
     site: normalizeAndValidateSite(
       diagnostics,
@@ -201,6 +186,7 @@ export function normalizeAndValidateConfig(
       rawConfig,
       activeEnv.main
     ),
+    assets: normalizeAndValidateAssets(diagnostics, configPath, rawConfig),
     wasm_modules: normalizeAndValidateModulePaths(
       diagnostics,
       configPath,
@@ -230,6 +216,8 @@ export function normalizeAndValidateConfig(
     [...Object.keys(config), "env"]
   );
 
+  experimental(diagnostics, rawConfig, "assets");
+
   return { config, diagnostics };
 }
 
@@ -242,19 +230,23 @@ function normalizeAndValidateBuild(
   rawBuild: Config["build"],
   configPath: string | undefined
 ): Config["build"] & { deprecatedUpload: DeprecatedUpload } {
-  const { command, cwd, watch_dir, upload, ...rest } = rawBuild;
+  const { command, cwd, watch_dir = "./src", upload, ...rest } = rawBuild;
   const deprecatedUpload: DeprecatedUpload = { ...upload };
   validateAdditionalProperties(diagnostics, "build", Object.keys(rest), []);
 
   validateOptionalProperty(diagnostics, "build", "command", command, "string");
   validateOptionalProperty(diagnostics, "build", "cwd", cwd, "string");
-  validateOptionalProperty(
-    diagnostics,
-    "build",
-    "watch_dir",
-    watch_dir,
-    "string"
-  );
+  if (Array.isArray(watch_dir)) {
+    validateTypedArray(diagnostics, "build.watch_dir", watch_dir, "string");
+  } else {
+    validateOptionalProperty(
+      diagnostics,
+      "build",
+      "watch_dir",
+      watch_dir,
+      "string"
+    );
+  }
 
   deprecated(
     diagnostics,
@@ -303,13 +295,18 @@ function normalizeAndValidateBuild(
       // - `configPath` will always be defined since `build` can only
       // be configured in `wrangler.toml`, but who knows, that may
       // change in the future, so we do a check anyway
-      command
-        ? configPath
-          ? path.relative(
+      command && configPath
+        ? Array.isArray(watch_dir)
+          ? watch_dir.map((dir) =>
+              path.relative(
+                process.cwd(),
+                path.join(path.dirname(configPath), `${dir}`)
+              )
+            )
+          : path.relative(
               process.cwd(),
-              path.join(path.dirname(configPath), watch_dir || "./src")
+              path.join(path.dirname(configPath), `${watch_dir}`)
             )
-          : watch_dir || "./src"
         : watch_dir,
     cwd,
     deprecatedUpload,
@@ -352,7 +349,7 @@ function normalizeAndValidateDev(
 ): DevConfig {
   const {
     ip = "localhost",
-    port = 8787,
+    port,
     local_protocol = "http",
     upstream_protocol = "https",
     host,
@@ -387,7 +384,8 @@ function normalizeAndValidateDev(
  */
 function normalizeAndValidateMigrations(
   diagnostics: Diagnostics,
-  rawMigrations: Config["migrations"]
+  rawMigrations: Config["migrations"],
+  durableObjects: Config["durable_objects"]
 ): Config["migrations"] {
   if (!Array.isArray(rawMigrations)) {
     diagnostics.errors.push(
@@ -398,29 +396,38 @@ function normalizeAndValidateMigrations(
     return [];
   } else {
     for (let i = 0; i < rawMigrations.length; i++) {
-      const migration = rawMigrations[i];
+      const { tag, new_classes, renamed_classes, deleted_classes, ...rest } =
+        rawMigrations[i];
+
+      validateAdditionalProperties(
+        diagnostics,
+        "migrations",
+        Object.keys(rest),
+        []
+      );
+
       validateRequiredProperty(
         diagnostics,
         `migrations[${i}]`,
         `tag`,
-        migration.tag,
+        tag,
         "string"
       );
       validateOptionalTypedArray(
         diagnostics,
         `migrations[${i}].new_classes`,
-        migration.new_classes,
+        new_classes,
         "string"
       );
-      if (migration.renamed_classes !== undefined) {
-        if (!Array.isArray(migration.renamed_classes)) {
+      if (renamed_classes !== undefined) {
+        if (!Array.isArray(renamed_classes)) {
           diagnostics.errors.push(
             `Expected "migrations[${i}].renamed_classes" to be an array of "{from: string, to: string}" objects but got ${JSON.stringify(
-              migration.renamed_classes
+              renamed_classes
             )}.`
           );
         } else if (
-          migration.renamed_classes.some(
+          renamed_classes.some(
             (c) =>
               typeof c !== "object" ||
               !isRequiredProperty(c, "from", "string") ||
@@ -429,7 +436,7 @@ function normalizeAndValidateMigrations(
         ) {
           diagnostics.errors.push(
             `Expected "migrations[${i}].renamed_classes" to be an array of "{from: string, to: string}" objects but got ${JSON.stringify(
-              migration.renamed_classes
+              renamed_classes
             )}.`
           );
         }
@@ -437,10 +444,49 @@ function normalizeAndValidateMigrations(
       validateOptionalTypedArray(
         diagnostics,
         `migrations[${i}].deleted_classes`,
-        migration.deleted_classes,
+        deleted_classes,
         "string"
       );
     }
+
+    if (
+      Array.isArray(durableObjects?.bindings) &&
+      durableObjects.bindings.length > 0
+    ) {
+      // intrinsic [durable_objects] implies [migrations]
+      const exportedDurableObjects = (durableObjects.bindings || []).filter(
+        (binding) => !binding.script_name
+      );
+      if (exportedDurableObjects.length > 0 && rawMigrations.length === 0) {
+        if (
+          !exportedDurableObjects.some(
+            (exportedDurableObject) =>
+              typeof exportedDurableObject.class_name !== "string"
+          )
+        ) {
+          const durableObjectClassnames = exportedDurableObjects.map(
+            (durable) => durable.class_name
+          );
+
+          diagnostics.warnings.push(
+            `In wrangler.toml, you have configured [durable_objects] exported by this Worker (${durableObjectClassnames.join(
+              ", "
+            )}), but no [migrations] for them. This may not work as expected until you add a [migrations] section to your wrangler.toml. Add this configuration to your wrangler.toml:
+
+  \`\`\`
+  [[migrations]]
+  tag = "v1" # Should be unique for each entry
+  new_classes = [${durableObjectClassnames
+    .map((name) => `"${name}"`)
+    .join(", ")}]
+  \`\`\`
+
+Refer to https://developers.cloudflare.com/workers/learning/using-durable-objects/#durable-object-migrations-in-wranglertoml for more details.`
+          );
+        }
+      }
+    }
+
     return rawMigrations;
   }
 }
@@ -528,6 +574,35 @@ function normalizeAndValidateSite(
   return undefined;
 }
 
+/**
+ * Validate the `assets` configuration and return normalized values.
+ */
+function normalizeAndValidateAssets(
+  diagnostics: Diagnostics,
+  configPath: string | undefined,
+  rawConfig: RawConfig
+) {
+  if (
+    typeof rawConfig?.assets === "string" ||
+    rawConfig?.assets === undefined
+  ) {
+    return rawConfig?.assets;
+  }
+
+  const { bucket, include = [], exclude = [], ...rest } = rawConfig.assets;
+
+  validateAdditionalProperties(diagnostics, "assets", Object.keys(rest), []);
+  validateRequiredProperty(diagnostics, "assets", "bucket", bucket, "string");
+  validateTypedArray(diagnostics, "assets.include", include, "string");
+  validateTypedArray(diagnostics, "assets.exclude", exclude, "string");
+
+  return {
+    bucket,
+    include,
+    exclude,
+  };
+}
+
 /**
  * Map the paths of the `wasm_modules`, `text_blobs` or `data_blobs` configuration to be relative to the current working directory.
  */
@@ -562,19 +637,37 @@ function normalizeAndValidateModulePaths(
  * 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))
-  );
+  if (!item) {
+    return false;
+  }
+  if (typeof item === "string") {
+    return true;
+  }
+  if (typeof item === "object") {
+    if (!hasProperty(item, "pattern") || typeof item.pattern !== "string") {
+      return false;
+    }
+
+    const otherKeys = Object.keys(item).length - 1; // minus one to subtract "pattern"
+
+    const hasZoneId =
+      hasProperty(item, "zone_id") && typeof item.zone_id === "string";
+    const hasZoneName =
+      hasProperty(item, "zone_name") && typeof item.zone_name === "string";
+    const hasCustomDomainFlag =
+      hasProperty(item, "custom_domain") &&
+      typeof item.custom_domain === "boolean";
+
+    if (otherKeys === 2 && hasCustomDomainFlag && (hasZoneId || hasZoneName)) {
+      return true;
+    } else if (
+      otherKeys === 1 &&
+      (hasZoneId || hasZoneName || hasCustomDomainFlag)
+    ) {
+      return true;
+    }
+  }
+  return false;
 }
 
 /**
@@ -583,7 +676,7 @@ function isValidRouteValue(item: unknown): boolean {
 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(
+      `Expected "${field}" to be either a string, or an object with shape { pattern, custom_domain, zone_id | zone_name }, but got ${JSON.stringify(
         value
       )}.`
     );
@@ -613,7 +706,7 @@ const isRouteArray: ValidatorFn = (diagnostics, field, value) => {
   }
   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(
+      `Expected "${field}" to be an array of either strings or objects with the shape { pattern, custom_domain, zone_id | zone_name }, but these weren't valid: ${JSON.stringify(
         invalidRoutes,
         null,
         2
@@ -696,27 +789,12 @@ function normalizeAndValidateEnvironment(
     diagnostics,
     rawEnv,
     "experimental_services",
-    `The "experimental_services" field is no longer supported. Instead, use [[unsafe.bindings]] to enable experimental features. Add this to your wrangler.toml:\n` +
-      "```\n" +
-      TOML.stringify({
-        unsafe: {
-          bindings: (rawEnv?.experimental_services || []).map(
-            (serviceDefinition) => {
-              return {
-                name: serviceDefinition.name,
-                type: "service",
-                service: serviceDefinition.service,
-                environment: serviceDefinition.environment,
-              };
-            }
-          ),
-        },
-      }) +
-      "```",
+    `The "experimental_services" field is no longer supported. Simply rename the [experimental_services] field to [services].`,
     true
   );
 
   experimental(diagnostics, rawEnv, "unsafe");
+  experimental(diagnostics, rawEnv, "services");
 
   const route = validateRoute(diagnostics, topLevelEnv, rawEnv);
 
@@ -880,6 +958,16 @@ function normalizeAndValidateEnvironment(
       validateBindingArray(envName, validateR2Binding),
       []
     ),
+    services: notInheritable(
+      diagnostics,
+      topLevelEnv,
+      rawConfig,
+      rawEnv,
+      envName,
+      "services",
+      validateBindingArray(envName, validateServiceBinding),
+      []
+    ),
     unsafe: notInheritable(
       diagnostics,
       topLevelEnv,
@@ -893,8 +981,22 @@ function normalizeAndValidateEnvironment(
       }
     ),
     zone_id: rawEnv.zone_id,
-    minify: rawEnv.minify,
-    node_compat: rawEnv.node_compat,
+    minify: inheritable(
+      diagnostics,
+      topLevelEnv,
+      rawEnv,
+      "minify",
+      isBoolean,
+      undefined
+    ),
+    node_compat: inheritable(
+      diagnostics,
+      topLevelEnv,
+      rawEnv,
+      "node_compat",
+      isBoolean,
+      undefined
+    ),
   };
 
   return environment;
@@ -1014,7 +1116,7 @@ const validateRule: ValidatorFn = (diagnostics, field, value) => {
 
   if (!isOptionalProperty(rule, "fallthrough", "boolean")) {
     diagnostics.errors.push(
-      `binding should, optionally, have a boolean "fallthrough" field.`
+      `the field "fallthrough", when present, should be a boolean.`
     );
     isValid = false;
   }
@@ -1135,7 +1237,7 @@ const validateDurableObjectBinding: ValidatorFn = (
     return false;
   }
 
-  // Durable Object bindings must have a name and class_name, and optionally a script_name.
+  // Durable Object bindings must have a name and class_name, and optionally a script_name and an environment.
   let isValid = true;
   if (!isRequiredProperty(value, "name", "string")) {
     diagnostics.errors.push(`binding should have a string "name" field.`);
@@ -1147,7 +1249,21 @@ const validateDurableObjectBinding: ValidatorFn = (
   }
   if (!isOptionalProperty(value, "script_name", "string")) {
     diagnostics.errors.push(
-      `binding should, optionally, have a string "script_name" field.`
+      `the field "script_name", when present, should be a string.`
+    );
+    isValid = false;
+  }
+  // environment requires a script_name
+  if (!isOptionalProperty(value, "environment", "string")) {
+    diagnostics.errors.push(
+      `the field "environment", when present, should be a string.`
+    );
+    isValid = false;
+  }
+
+  if ("environment" in value && !("script_name" in value)) {
+    diagnostics.errors.push(
+      `binding should have a "script_name" field if "environment" is present.`
     );
     isValid = false;
   }
@@ -1178,8 +1294,13 @@ const validateUnsafeBinding: ValidatorFn = (diagnostics, field, value) => {
     const safeBindings = [
       "plain_text",
       "json",
+      "wasm_module",
+      "data_blob",
+      "text_blob",
       "kv_namespace",
       "durable_object_namespace",
+      "r2_bucket",
+      "service",
     ];
 
     if (safeBindings.includes(value.type)) {
@@ -1422,3 +1543,38 @@ const validateBindingsHaveUniqueNames = (
 
   return !hasDuplicates;
 };
+const validateServiceBinding: ValidatorFn = (diagnostics, field, value) => {
+  if (typeof value !== "object" || value === null) {
+    diagnostics.errors.push(
+      `"services" bindings should be objects, but got ${JSON.stringify(value)}`
+    );
+    return false;
+  }
+  let isValid = true;
+  // Service bindings must have a binding, service, and environment.
+  if (!isRequiredProperty(value, "binding", "string")) {
+    diagnostics.errors.push(
+      `"${field}" bindings should have a string "binding" field but got ${JSON.stringify(
+        value
+      )}.`
+    );
+    isValid = false;
+  }
+  if (!isRequiredProperty(value, "service", "string")) {
+    diagnostics.errors.push(
+      `"${field}" bindings should have a string "service" field but got ${JSON.stringify(
+        value
+      )}.`
+    );
+    isValid = false;
+  }
+  if (!isOptionalProperty(value, "environment", "string")) {
+    diagnostics.errors.push(
+      `"${field}" bindings should have a string "environment" field but got ${JSON.stringify(
+        value
+      )}.`
+    );
+    isValid = false;
+  }
+  return isValid;
+};

package/src/create-worker-preview.ts

@@ -63,10 +63,15 @@ async function sessionToken(
 ): Promise<CfPreviewToken> {
   const { accountId } = account;
   const initUrl = ctx.zone
-    ? `/zones/${ctx.zone.id}/workers/edge-preview`
+    ? `/zones/${ctx.zone}/workers/edge-preview`
     : `/accounts/${accountId}/workers/subdomain/edge-preview`;
 
-  const { exchange_url } = await fetchResult<{ exchange_url: string }>(initUrl);
+  const { exchange_url } = await fetchResult<{ exchange_url: string }>(
+    initUrl,
+    undefined,
+    undefined,
+    abortSignal
+  );
   const { inspector_websocket, prewarm, token } = (await (
     await fetch(exchange_url, { signal: abortSignal })
   ).json()) as { inspector_websocket: string; token: string; prewarm: string };
@@ -106,7 +111,7 @@ async function createPreviewToken(
   );
 
   const { accountId } = account;
-  const scriptId = ctx.zone ? randomId() : worker.name || host.split(".")[0];
+  const scriptId = worker.name || (ctx.zone ? randomId() : host.split(".")[0]);
   const url =
     ctx.env && !ctx.legacyEnv
       ? `/accounts/${accountId}/workers/services/${scriptId}/environments/${ctx.env}/edge-preview`
@@ -119,29 +124,34 @@ async function createPreviewToken(
   const formData = createWorkerUploadForm(worker);
   formData.set("wrangler-session-config", JSON.stringify(mode));
 
-  const { preview_token } = await fetchResult<{ preview_token: string }>(url, {
-    method: "POST",
-    body: formData,
-    headers: {
-      "cf-preview-upload-config-token": value,
+  const { preview_token } = await fetchResult<{ preview_token: string }>(
+    url,
+    {
+      method: "POST",
+      body: formData,
+      headers: {
+        "cf-preview-upload-config-token": value,
+      },
     },
-  });
+    undefined,
+    abortSignal
+  );
 
   return {
     value: preview_token,
-    host: ctx.zone
-      ? ctx.zone.host
-      : worker.name
-      ? `${
-          worker.name
-          // TODO: this should also probably have the env prefix
-          // but it doesn't appear to work yet, instead giving us the
-          // "There is nothing here yet" screen
-          // ctx.env && !ctx.legacyEnv
-          //   ? `${ctx.env}.${worker.name}`
-          //   : worker.name
-        }.${host.split(".").slice(1).join(".")}`
-      : host,
+    host:
+      ctx.host ??
+      (worker.name
+        ? `${
+            worker.name
+            // TODO: this should also probably have the env prefix
+            // but it doesn't appear to work yet, instead giving us the
+            // "There is nothing here yet" screen
+            // ctx.env && !ctx.legacyEnv
+            //   ? `${ctx.env}.${worker.name}`
+            //   : worker.name
+          }.${host.split(".").slice(1).join(".")}`
+        : host),
 
     inspectorUrl,
     prewarmUrl,

package/src/create-worker-upload-form.ts

@@ -32,20 +32,24 @@ export interface WorkerMetadata {
   compatibility_flags?: string[];
   usage_model?: "bundled" | "unbound";
   migrations?: CfDurableObjectMigrations;
+  // If you add any new binding types here, also add it to safeBindings
+  // under validateUnsafeBinding in config/validation.ts
   bindings: (
-    | { type: "kv_namespace"; name: string; namespace_id: string }
     | { type: "plain_text"; name: string; text: string }
     | { type: "json"; name: string; json: unknown }
     | { type: "wasm_module"; name: string; part: string }
     | { type: "text_blob"; name: string; part: string }
     | { type: "data_blob"; name: string; part: string }
+    | { type: "kv_namespace"; name: string; namespace_id: string }
     | {
         type: "durable_object_namespace";
         name: string;
         class_name: string;
         script_name?: string;
+        environment?: string;
       }
     | { type: "r2_bucket"; name: string; bucket_name: string }
+    | { type: "service"; name: string; service: string; environment?: string }
   )[];
 }
 
@@ -67,6 +71,14 @@ export function createWorkerUploadForm(worker: CfWorkerInit): FormData {
 
   const metadataBindings: WorkerMetadata["bindings"] = [];
 
+  Object.entries(bindings.vars || {})?.forEach(([key, value]) => {
+    if (typeof value === "string") {
+      metadataBindings.push({ name: key, type: "plain_text", text: value });
+    } else {
+      metadataBindings.push({ name: key, type: "json", json: value });
+    }
+  });
+
   bindings.kv_namespaces?.forEach(({ id, binding }) => {
     metadataBindings.push({
       name: binding,
@@ -76,12 +88,13 @@ export function createWorkerUploadForm(worker: CfWorkerInit): FormData {
   });
 
   bindings.durable_objects?.bindings.forEach(
-    ({ name, class_name, script_name }) => {
+    ({ name, class_name, script_name, environment }) => {
       metadataBindings.push({
         name,
         type: "durable_object_namespace",
         class_name: class_name,
         ...(script_name && { script_name }),
+        ...(environment && { environment }),
       });
     }
   );
@@ -94,12 +107,13 @@ export function createWorkerUploadForm(worker: CfWorkerInit): FormData {
     });
   });
 
-  Object.entries(bindings.vars || {})?.forEach(([key, value]) => {
-    if (typeof value === "string") {
-      metadataBindings.push({ name: key, type: "plain_text", text: value });
-    } else {
-      metadataBindings.push({ name: key, type: "json", json: value });
-    }
+  bindings.services?.forEach(({ binding, service, environment }) => {
+    metadataBindings.push({
+      name: binding,
+      type: "service",
+      service,
+      ...(environment && { environment }),
+    });
   });
 
   for (const [name, filePath] of Object.entries(bindings.wasm_modules || {})) {