wrangler 0.0.0-e2b7352 → 0.0.0-e2f9bb2

package/src/config/validation.ts

@@ -24,6 +24,7 @@ import {
   inheritableInLegacyEnvironments,
   appendEnvName,
   getBindingNames,
+  isValidName,
 } from "./validation-helpers";
 import type { Config, DevConfig, RawConfig, RawDevConfig } from "./config";
 import type {
@@ -61,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(
@@ -91,12 +94,35 @@ 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"] ??
     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,
     configPath,
@@ -169,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,
@@ -182,6 +213,12 @@ export function normalizeAndValidateConfig(
       "text_blobs",
       rawConfig.text_blobs
     ),
+    data_blobs: normalizeAndValidateModulePaths(
+      diagnostics,
+      configPath,
+      "data_blobs",
+      rawConfig.data_blobs
+    ),
   };
 
   validateBindingsHaveUniqueNames(diagnostics, config);
@@ -190,7 +227,7 @@ export function normalizeAndValidateConfig(
     diagnostics,
     "top-level",
     Object.keys(rawConfig),
-    [...Object.keys(config), "env", "miniflare"]
+    [...Object.keys(config), "env"]
   );
 
   return { config, diagnostics };
@@ -413,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) {
@@ -455,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.
  */
@@ -520,22 +718,10 @@ 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,
@@ -554,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(
@@ -613,7 +801,7 @@ function normalizeAndValidateEnvironment(
       topLevelEnv,
       rawEnv,
       "name",
-      isString,
+      isValidName,
       appendEnvName(envName),
       undefined
     ),
@@ -705,6 +893,8 @@ function normalizeAndValidateEnvironment(
       }
     ),
     zone_id: rawEnv.zone_id,
+    minify: rawEnv.minify,
+    node_compat: rawEnv.node_compat,
   };
 
   return environment;
@@ -748,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 }) +
           "```"
@@ -921,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")
           );
         }
@@ -1100,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
       )}`
     );
@@ -1140,7 +1330,7 @@ const validateR2Binding: ValidatorFn = (diagnostics, field, value) => {
  *
  * 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,
+ * what exactly would live at `env.DATA` (or in the case of service-workers,
  * the `DATA` global).
  */
 const validateBindingsHaveUniqueNames = (
@@ -1153,6 +1343,7 @@ const validateBindingsHaveUniqueNames = (
     unsafe,
     vars,
     wasm_modules,
+    data_blobs,
   }: Partial<Config>
 ): boolean => {
   let hasDuplicates = false;
@@ -1165,6 +1356,7 @@ const validateBindingsHaveUniqueNames = (
     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[]> = {};

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 });
+};

package/src/create-worker-preview.ts

@@ -2,6 +2,7 @@ import { URL } from "node:url";
 import { fetch } from "undici";
 import { fetchResult } from "./cfetch";
 import { createWorkerUploadForm } from "./create-worker-upload-form";
+import { logger } from "./logger";
 import type { CfAccount, CfWorkerContext, CfWorkerInit } from "./worker";
 
 /**
@@ -57,7 +58,8 @@ export interface CfPreviewToken {
  */
 async function sessionToken(
   account: CfAccount,
-  ctx: CfWorkerContext
+  ctx: CfWorkerContext,
+  abortSignal: AbortSignal
 ): Promise<CfPreviewToken> {
   const { accountId } = account;
   const initUrl = ctx.zone
@@ -65,9 +67,9 @@ async function sessionToken(
     : `/accounts/${accountId}/workers/subdomain/edge-preview`;
 
   const { exchange_url } = await fetchResult<{ exchange_url: string }>(initUrl);
-  const { inspector_websocket, token } = (await (
-    await fetch(exchange_url)
-  ).json()) as { inspector_websocket: string; token: string };
+  const { inspector_websocket, prewarm, token } = (await (
+    await fetch(exchange_url, { signal: abortSignal })
+  ).json()) as { inspector_websocket: string; token: string; prewarm: string };
   const { host } = new URL(inspector_websocket);
   const query = `cf_workers_preview_token=${token}`;
 
@@ -75,9 +77,7 @@ async function sessionToken(
     value: token,
     host,
     inspectorUrl: new URL(`${inspector_websocket}?${query}`),
-    prewarmUrl: new URL(
-      `https://${host}/cdn-cgi/workers/preview/prewarm?${query}`
-    ),
+    prewarmUrl: new URL(prewarm),
   };
 }
 
@@ -96,11 +96,13 @@ function randomId(): string {
 async function createPreviewToken(
   account: CfAccount,
   worker: CfWorkerInit,
-  ctx: CfWorkerContext
+  ctx: CfWorkerContext,
+  abortSignal: AbortSignal
 ): Promise<CfPreviewToken> {
   const { value, host, inspectorUrl, prewarmUrl } = await sessionToken(
     account,
-    ctx
+    ctx,
+    abortSignal
   );
 
   const { accountId } = account;
@@ -155,12 +157,19 @@ async function createPreviewToken(
 export async function createWorkerPreview(
   init: CfWorkerInit,
   account: CfAccount,
-  ctx: CfWorkerContext
+  ctx: CfWorkerContext,
+  abortSignal: AbortSignal
 ): Promise<CfPreviewToken> {
-  const token = await createPreviewToken(account, init, ctx);
-  const response = await fetch(token.prewarmUrl.href, { method: "POST" });
+  const token = await createPreviewToken(account, init, ctx, abortSignal);
+  const response = await fetch(token.prewarmUrl.href, {
+    method: "POST",
+    signal: abortSignal,
+    headers: {
+      "cf-workers-preview-token": token.value,
+    },
+  });
   if (!response.ok) {
-    // console.error("worker failed to prewarm: ", response.statusText);
+    logger.warn("worker failed to prewarm: ", response.statusText);
   }
   return token;
 }

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

@@ -26,7 +26,7 @@ export function toMimeType(type: CfModuleType): string {
 export interface WorkerMetadata {
   /** The name of the entry point module. Only exists when the worker is in the ES module format */
   main_module?: string;
-  /** The name of the entry point module. Only exists when the worker is in the Service Worker format */
+  /** The name of the entry point module. Only exists when the worker is in the service-worker format */
   body_part?: string;
   compatibility_date?: string;
   compatibility_flags?: string[];
@@ -38,6 +38,7 @@ export interface WorkerMetadata {
     | { 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: "durable_object_namespace";
         name: string;
@@ -133,6 +134,21 @@ export function createWorkerUploadForm(worker: CfWorkerInit): FormData {
     }
   }
 
+  for (const [name, filePath] of Object.entries(bindings.data_blobs || {})) {
+    metadataBindings.push({
+      name,
+      type: "data_blob",
+      part: name,
+    });
+
+    formData.set(
+      name,
+      new File([readFileSync(filePath)], filePath, {
+        type: "application/octet-stream",
+      })
+    );
+  }
+
   if (main.type === "commonjs") {
     // This is a service-worker format worker.
     for (const module of Object.values([...(modules || [])])) {
@@ -146,8 +162,12 @@ export function createWorkerUploadForm(worker: CfWorkerInit): FormData {
         );
         // And then remove it from the modules collection
         modules = modules?.filter((m) => m !== module);
-      } else if (module.type === "compiled-wasm" || module.type === "text") {
-        // Convert all wasm/text modules into `wasm_module`/`text_blob` bindings.
+      } else if (
+        module.type === "compiled-wasm" ||
+        module.type === "text" ||
+        module.type === "buffer"
+      ) {
+        // Convert all wasm/text/data modules into `wasm_module`/`text_blob`/`data_blob` bindings.
         // The "name" of the module is a file path. We use it
         // to instead be a "part" of the body, and a reference
         // that we can use inside our source. This identifier has to be a valid
@@ -156,7 +176,12 @@ export function createWorkerUploadForm(worker: CfWorkerInit): FormData {
         const name = module.name.replace(/[^a-zA-Z0-9_$]/g, "_");
         metadataBindings.push({
           name,
-          type: module.type === "compiled-wasm" ? "wasm_module" : "text_blob",
+          type:
+            module.type === "compiled-wasm"
+              ? "wasm_module"
+              : module.type === "text"
+              ? "text_blob"
+              : "data_blob",
           part: name,
         });
 
@@ -167,15 +192,13 @@ export function createWorkerUploadForm(worker: CfWorkerInit): FormData {
             type:
               module.type === "compiled-wasm"
                 ? "application/wasm"
-                : "text/plain",
+                : module.type === "text"
+                ? "text/plain"
+                : "application/octet-stream",
           })
         );
         // And then remove it from the modules collection
         modules = modules?.filter((m) => m !== module);
-      } else if (module.type === "buffer") {
-        throw new Error(
-          'The "buffer" module type is not yet supported in service worker format workers'
-        );
       }
     }
   }

package/src/dev/dev-vars.ts

@@ -0,0 +1,36 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import dotenv from "dotenv";
+import { logger } from "../logger";
+import type { Config } from "../config";
+
+/**
+ * Get the Worker `vars` bindings for a `wrangler dev` instance of a Worker.
+ *
+ * The `vars` bindings can be specified in the `wrangler.toml` configuration file.
+ * But "secret" `vars` are usually only provided at the server -
+ * either by creating them in the Dashboard UI, or using the `wrangler secret` command.
+ *
+ * It is useful during development, to provide these types of variable locally.
+ * When running `wrangler dev` we will look for a file called `.dev.vars`, situated
+ * next to the `wrangler.toml` file (or in the current working directory if there is no
+ * `wrangler.toml`).
+ *
+ * Any values in this file, formatted like a `dotenv` file, will add to or override `vars`
+ * bindings provided in the `wrangler.toml`.
+ */
+export function getVarsForDev(config: Config): Config["vars"] {
+  const configDir = path.resolve(path.dirname(config.configPath ?? "."));
+  const devVarsPath = path.resolve(configDir, ".dev.vars");
+  if (fs.existsSync(devVarsPath)) {
+    const devVarsRelativePath = path.relative(process.cwd(), devVarsPath);
+    logger.log(`Using vars defined in ${devVarsRelativePath}`);
+    const devVars = dotenv.parse(fs.readFileSync(devVarsPath, "utf8"));
+    return {
+      ...config.vars,
+      ...devVars,
+    };
+  } else {
+    return config.vars;
+  }
+}