wrangler 0.0.0-e88a54e → 0.0.0-e95e5a0

package/src/__tests__/whoami.test.tsx

@@ -1,15 +1,21 @@
 import { render } from "ink-testing-library";
 import React from "react";
-import { reinitialiseAuthTokens, writeAuthConfigFile } from "../user";
+import { writeAuthConfigFile } from "../user";
 import { getUserInfo, WhoAmI } from "../whoami";
 import { setMockResponse } from "./helpers/mock-cfetch";
 import { mockConsoleMethods } from "./helpers/mock-console";
+import { useMockIsTTY } from "./helpers/mock-istty";
 import { runInTempDir } from "./helpers/run-in-tmp";
 import type { UserInfo } from "../whoami";
 
 describe("getUserInfo()", () => {
   runInTempDir({ homedir: "./home" });
   const std = mockConsoleMethods();
+  const { setIsTTY } = useMockIsTTY();
+
+  beforeEach(() => {
+    setIsTTY(true);
+  });
 
   it("should return undefined if there is no config file", async () => {
     const userInfo = await getUserInfo();
@@ -18,16 +24,12 @@ describe("getUserInfo()", () => {
 
   it("should return undefined if there is an empty config file", async () => {
     writeAuthConfigFile({});
-    // Now that we have changed the auth tokens in the wrangler.toml we must reinitialize the user auth state.
-    reinitialiseAuthTokens();
     const userInfo = await getUserInfo();
     expect(userInfo).toBeUndefined();
   });
 
   it("should return the user's email and accounts if authenticated via config token", async () => {
     writeAuthConfigFile({ oauth_token: "some-oauth-token" });
-    // Now that we have changed the auth tokens in the wrangler.toml we must reinitialize the user auth state.
-    reinitialiseAuthTokens();
 
     setMockResponse("/user", () => {
       return { email: "user@example.com" };
@@ -56,12 +58,15 @@ describe("getUserInfo()", () => {
 
   it("should display a warning message if the config file contains a legacy api_token field", async () => {
     writeAuthConfigFile({ api_token: "API_TOKEN" });
-    await reinitialiseAuthTokens();
     await getUserInfo();
     expect(std.warn).toMatchInlineSnapshot(`
-      "It looks like you have used Wrangler 1's \`config\` command to login with an API token.
-      This is no longer supported in the current version of Wrangler.
-      If you wish to authenticate via an API token then please set the \`CLOUDFLARE_API_TOKEN\` environment variable."
+      "▲ [WARNING] It looks like you have used Wrangler 1's \`config\` command to login with an API token.
+
+        This is no longer supported in the current version of Wrangler.
+        If you wish to authenticate via an API token then please set the \`CLOUDFLARE_API_TOKEN\`
+        environment variable.
+
+      "
     `);
   });
 });

package/src/bundle.ts

@@ -1,6 +1,8 @@
 import assert from "node:assert";
 import * as fs from "node:fs";
 import * as path from "node:path";
+import NodeGlobalsPolyfills from "@esbuild-plugins/node-globals-polyfill";
+import NodeModulesPolyfills from "@esbuild-plugins/node-modules-polyfill";
 import * as esbuild from "esbuild";
 import createModuleCollector from "./module-collection";
 import type { Config } from "./config";
@@ -26,10 +28,21 @@ export async function bundleWorker(
     jsxFragment: string | undefined;
     rules: Config["rules"];
     watch?: esbuild.WatchMode;
+    tsconfig: string | undefined;
+    minify: boolean | undefined;
+    nodeCompat: boolean | undefined;
   }
 ): Promise<BundleResult> {
-  const { serveAssetsFromWorker, jsxFactory, jsxFragment, rules, watch } =
-    options;
+  const {
+    serveAssetsFromWorker,
+    jsxFactory,
+    jsxFragment,
+    rules,
+    watch,
+    tsconfig,
+    minify,
+    nodeCompat,
+  } = options;
   const entryDirectory = path.dirname(entry.file);
   const moduleCollector = createModuleCollector({
     wrangler1xlegacyModuleReferences: {
@@ -54,17 +67,31 @@ export async function bundleWorker(
     outdir: destination,
     external: ["__STATIC_CONTENT_MANIFEST"],
     format: "esm",
+    target: "es2020",
     sourcemap: true,
+    minify,
     metafile: true,
     conditions: ["worker", "browser"],
+    ...(process.env.NODE_ENV && {
+      define: {
+        "process.env.NODE_ENV": `"${process.env.NODE_ENV}"`,
+        ...(nodeCompat ? { global: "globalThis" } : {}),
+      },
+    }),
     loader: {
       ".js": "jsx",
       ".mjs": "jsx",
       ".cjs": "jsx",
     },
-    plugins: [moduleCollector.plugin],
+    plugins: [
+      moduleCollector.plugin,
+      ...(nodeCompat
+        ? [NodeGlobalsPolyfills({ buffer: true }), NodeModulesPolyfills()]
+        : []),
+    ],
     ...(jsxFactory && { jsxFactory }),
     ...(jsxFragment && { jsxFragment }),
+    ...(tsconfig && { tsconfig }),
     watch,
   });
 

package/src/cfetch/internal.ts

@@ -1,7 +1,6 @@
 import { fetch, Headers } from "undici";
 import { getEnvironmentVariableFactory } from "../environment-variables";
 import { ParseError, parseJSON } from "../parse";
-import { reportError } from "../reporting";
 import { getAPIToken, loginOrRefreshIfRequired } from "../user";
 import type { URLSearchParams } from "node:url";
 import type { RequestInit, HeadersInit } from "undici";
@@ -48,7 +47,6 @@ export async function fetchInternal<ResponseType>(
   try {
     return parseJSON(jsonText) as ResponseType;
   } catch (err) {
-    await reportError(err as Error);
     throw new ParseError({
       text: "Received a malformed response from the API",
       notes: [

package/src/cli.ts

@@ -1,19 +1,13 @@
+import "dotenv/config"; // Grab locally specified env params from a `.env` file.
 import process from "process";
 import { hideBin } from "yargs/helpers";
-import { reportError, initReporting } from "./reporting";
+import { FatalError } from "./errors";
 import { main } from ".";
 
-try {
-  initReporting();
-} catch (error) {}
-
-process.on("uncaughtExceptionMonitor", async (err, origin) => {
-  await reportError(err, origin);
-});
-
-main(hideBin(process.argv)).catch(() => {
+main(hideBin(process.argv)).catch((e) => {
   // The logging of any error that was thrown from `main()` is handled in the `yargs.fail()` handler.
   // Here we just want to ensure that the process exits with a non-zero code.
   // We don't want to do this inside the `main()` function, since that would kill the process when running our tests.
-  process.exit(1);
+  const exitCode = (e instanceof FatalError && e.code) || 1;
+  process.exit(exitCode);
 });

package/src/config/README.md

@@ -48,7 +48,7 @@ This function will return:
 - a `Diagnostics` object, which contains any errors or warnings from the validation process
 
 The field values may have been parsed directly from the `RawConfig`, inherited into a named environment from the top-level environment, or given a default value.
-Generally, if there are any warnings they should be presented to the user via `console.warn()` messages,
+Generally, if there are any warnings they should be presented to the user via `logger.warn()` messages,
 and if there are any errors then an `Error` should be thrown describing these errors.
 
 The `Diagnostics` object is hierarchical: each `Diagnostics` instance can contain a collection of child `Diagnostics` instance.

package/src/config/config.ts

@@ -135,6 +135,17 @@ export interface ConfigFields<Dev extends RawDevConfig> {
         [key: string]: string;
       }
     | undefined;
+
+  /**
+   * A list of data files that your worker should be bound to. This is
+   * the "legacy" way of binding to a data file. ES module workers should
+   * do proper module imports.
+   */
+  data_blobs:
+    | {
+        [key: string]: string;
+      }
+    | undefined;
 }
 
 export interface DevConfig {
@@ -142,7 +153,6 @@ export interface DevConfig {
    * IP address for the local dev server to listen on,
    *
    * @default `localhost`
-   * @todo this needs to be implemented
    */
   ip: string;
 
@@ -157,7 +167,6 @@ export interface DevConfig {
    * Protocol that local wrangler dev server listens to requests on.
    *
    * @default `http`
-   * @todo this needs to be implemented
    */
   local_protocol: "http" | "https";
 
@@ -168,13 +177,14 @@ export interface DevConfig {
    * See https://github.com/cloudflare/wrangler2/issues/583
    *
    * @default `https`
+   * @todo this needs to be implemented https://github.com/cloudflare/wrangler2/issues/583
    */
   upstream_protocol: "https" | "http";
 
   /**
-   * Host to forward requests to, defaults to the zone of project
+   * Host to forward requests to, defaults to the host of the first route of project
    */
-  host: string | undefined;
+  host: Config["route"];
 }
 
 export type RawDevConfig = Partial<DevConfig>;
@@ -197,6 +207,12 @@ export interface DeprecatedConfigFields {
    * @breaking
    */
   webpack_config?: string;
+
+  /**
+   * Configuration only used by a standalone use of the miniflare binary.
+   * @deprecated
+   */
+  miniflare?: unknown;
 }
 
 interface EnvironmentMap {

package/src/config/environment.ts

@@ -64,7 +64,7 @@ interface EnvironmentInheritable {
    * @breaking
    * @inheritable
    */
-  workers_dev: boolean;
+  workers_dev: boolean | undefined;
 
   /**
    * A list of routes that your worker should be published to.
@@ -74,7 +74,13 @@ interface EnvironmentInheritable {
    *
    * @inheritable
    */
-  routes: string[] | undefined;
+  routes:
+    | (
+        | string
+        | { pattern: string; zone_id: string }
+        | { pattern: string; zone_name: string }
+      )[]
+    | undefined;
 
   /**
    * A route that your worker should be published to. Literally
@@ -85,7 +91,18 @@ interface EnvironmentInheritable {
    *
    * @inheritable
    */
-  route: string | undefined;
+  route:
+    | (
+        | string
+        | { pattern: string; zone_id: string }
+        | { pattern: string; zone_name: string }
+      )
+    | undefined;
+
+  /**
+   * Path to a custom tsconfig
+   */
+  tsconfig: string | undefined;
 
   /**
    * The function to use to replace jsx syntax.
@@ -126,7 +143,7 @@ interface EnvironmentInheritable {
    *
    * @inheritable
    */
-  usage_model: undefined | "bundled" | "unbound";
+  usage_model: "bundled" | "unbound" | undefined;
 
   /**
    * An ordered list of rules that define which modules to import,
@@ -160,6 +177,17 @@ interface EnvironmentInheritable {
     upload?: DeprecatedUpload;
   };
 
+  /**
+   * Minify the script before uploading.
+   * @inheritable
+   */
+  minify: boolean | undefined;
+
+  /**
+   * Add polyfills for node builtin modules and globals
+   */
+  node_compat: boolean | undefined;
+
   /**
    * TODO: remove this as it has been deprecated.
    *

package/src/config/index.ts

@@ -1,4 +1,5 @@
 import { findUpSync } from "find-up";
+import { logger } from "../logger";
 import { parseTOML, readFileSync } from "../parse";
 import { normalizeAndValidateConfig } from "./validation";
 import type { Config, RawConfig } from "./config";
@@ -21,7 +22,7 @@ export type {
  */
 export function readConfig(
   configPath: string | undefined,
-  envName: string | undefined
+  args: unknown
 ): Config {
   let rawConfig: RawConfig = {};
   if (!configPath) {
@@ -37,11 +38,11 @@ export function readConfig(
   const { config, diagnostics } = normalizeAndValidateConfig(
     rawConfig,
     configPath,
-    envName
+    args
   );
 
   if (diagnostics.hasWarnings()) {
-    console.warn(diagnostics.renderWarnings());
+    logger.warn(diagnostics.renderWarnings());
   }
   if (diagnostics.hasErrors()) {
     throw new Error(diagnostics.renderErrors());

package/src/config/validation-helpers.ts

@@ -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];
     }
@@ -58,11 +60,14 @@ export function inheritable<K extends keyof Environment>(
   rawEnv: RawEnvironment,
   field: K,
   validate: ValidatorFn,
-  defaultValue: Environment[K]
+  defaultValue: Environment[K],
+  transformFn: TransformFn<Environment[K]> = (v) => v
 ): Environment[K] {
   validate(diagnostics, field, rawEnv[field], topLevelEnv);
   return (
-    (rawEnv[field] as Environment[K]) ?? topLevelEnv?.[field] ?? defaultValue
+    (rawEnv[field] as Environment[K]) ??
+    transformFn(topLevelEnv?.[field]) ??
+    defaultValue
   );
 }
 
@@ -76,6 +81,7 @@ export function inheritableInLegacyEnvironments<K extends keyof Environment>(
   rawEnv: RawEnvironment,
   field: K,
   validate: ValidatorFn,
+  transformFn: TransformFn<Environment[K]> = (v) => v,
   defaultValue: Environment[K]
 ): Environment[K] {
   return topLevelEnv === undefined || isLegacyEnv === true
@@ -85,7 +91,8 @@ export function inheritableInLegacyEnvironments<K extends keyof Environment>(
         rawEnv,
         field,
         validate,
-        defaultValue
+        defaultValue,
+        transformFn
       )
     : notAllowedInNamedServiceEnvironment(
         diagnostics,
@@ -95,6 +102,19 @@ export function inheritableInLegacyEnvironments<K extends keyof Environment>(
       );
 }
 
+/**
+ * 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.
@@ -207,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.
  */
@@ -484,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);