wrangler 0.0.0-e043479 → 0.0.0-e0b9366

package/src/__tests__/route.test.ts

@@ -0,0 +1,45 @@
+import { mockConsoleMethods } from "./helpers/mock-console";
+import { runInTempDir } from "./helpers/run-in-tmp";
+import { runWrangler } from "./helpers/run-wrangler";
+
+describe("wrangler route", () => {
+  mockConsoleMethods();
+  runInTempDir();
+
+  it("shows a deprecation notice when `wrangler route` is run", async () => {
+    await expect(runWrangler("route")).rejects
+      .toThrowErrorMatchingInlineSnapshot(`
+            "DEPRECATION WARNING:
+            \`wrangler route\` has been deprecated.
+            Please use wrangler.toml and/or \`wrangler publish --routes\` to modify routes"
+          `);
+  });
+
+  it("shows a deprecation notice when `wrangler route delete` is run", async () => {
+    await expect(runWrangler("route delete")).rejects
+      .toThrowErrorMatchingInlineSnapshot(`
+            "DEPRECATION WARNING:
+            \`wrangler route delete\` has been deprecated.
+            Remove the unwanted route(s) from wrangler.toml and run \`wrangler publish\` to remove your worker from those routes."
+          `);
+  });
+
+  it("shows a deprecation notice when `wrangler route delete <id>` is run", async () => {
+    await expect(runWrangler("route delete some-zone-id")).rejects
+      .toThrowErrorMatchingInlineSnapshot(`
+            "DEPRECATION WARNING:
+            \`wrangler route delete\` has been deprecated.
+            Remove the unwanted route(s) from wrangler.toml and run \`wrangler publish\` to remove your worker from those routes."
+          `);
+  });
+
+  it("shows a deprecation notice when `wrangler route list` is run", async () => {
+    await expect(runWrangler("route list")).rejects
+      .toThrowErrorMatchingInlineSnapshot(`
+            "DEPRECATION WARNING:
+            \`wrangler route list\` has been deprecated.
+            Refer to wrangler.toml for a list of routes the worker will be deployed to upon publishing.
+            Refer to the Cloudflare Dashboard to see the routes this worker is currently running on."
+          `);
+  });
+});

package/src/__tests__/whoami.test.tsx

@@ -1,30 +1,34 @@
 import { render } from "ink-testing-library";
 import React from "react";
-import { initialise } from "../user";
+import { reinitialiseAuthTokens, writeAuthConfigFile } from "../user";
 import { getUserInfo, WhoAmI } from "../whoami";
 import { setMockResponse } from "./helpers/mock-cfetch";
-import { writeUserConfig } from "./helpers/mock-user";
+import { mockConsoleMethods } from "./helpers/mock-console";
 import { runInTempDir } from "./helpers/run-in-tmp";
 import type { UserInfo } from "../whoami";
 
 describe("getUserInfo()", () => {
   runInTempDir({ homedir: "./home" });
+  const std = mockConsoleMethods();
 
   it("should return undefined if there is no config file", async () => {
-    await initialise();
     const userInfo = await getUserInfo();
     expect(userInfo).toBeUndefined();
   });
 
   it("should return undefined if there is an empty config file", async () => {
-    writeUserConfig();
-    await initialise();
+    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 () => {
-    writeUserConfig("some-oauth-token");
+    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" };
     });
@@ -36,7 +40,6 @@ describe("getUserInfo()", () => {
       ];
     });
 
-    await initialise();
     const userInfo = await getUserInfo();
 
     expect(userInfo).toEqual({
@@ -50,6 +53,17 @@ 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."
+    `);
+  });
 });
 
 describe("WhoAmI component", () => {

package/src/bundle.ts

@@ -2,10 +2,10 @@ import assert from "node:assert";
 import * as fs from "node:fs";
 import * as path from "node:path";
 import * as esbuild from "esbuild";
-import makeModuleCollector from "./module-collection";
-import type { CfModule, CfScriptFormat } from "./api/worker";
+import createModuleCollector from "./module-collection";
 import type { Config } from "./config";
 import type { Entry } from "./entry";
+import type { CfModule } from "./worker";
 
 type BundleResult = {
   modules: CfModule[];
@@ -24,20 +24,29 @@ export async function bundleWorker(
     serveAssetsFromWorker: boolean;
     jsxFactory: string | undefined;
     jsxFragment: string | undefined;
-    format: CfScriptFormat;
     rules: Config["rules"];
     watch?: esbuild.WatchMode;
   }
 ): Promise<BundleResult> {
-  const {
-    serveAssetsFromWorker,
-    jsxFactory,
-    jsxFragment,
-    format,
+  const { serveAssetsFromWorker, jsxFactory, jsxFragment, rules, watch } =
+    options;
+  const entryDirectory = path.dirname(entry.file);
+  const moduleCollector = createModuleCollector({
+    wrangler1xlegacyModuleReferences: {
+      rootDirectory: entryDirectory,
+      fileNames: new Set(
+        fs
+          .readdirSync(entryDirectory, { withFileTypes: true })
+          .filter(
+            (dirEntry) =>
+              dirEntry.isFile() && dirEntry.name !== path.basename(entry.file)
+          )
+          .map((dirEnt) => dirEnt.name)
+      ),
+    },
+    format: entry.format,
     rules,
-    watch,
-  } = options;
-  const moduleCollector = makeModuleCollector({ format, rules });
+  });
   const result = await esbuild.build({
     ...getEntryPoint(entry.file, serveAssetsFromWorker),
     bundle: true,

package/src/cfetch/internal.ts

@@ -1,6 +1,7 @@
-import { fetch } from "undici";
+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";
@@ -47,6 +48,7 @@ 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: [
@@ -72,7 +74,11 @@ function truncate(text: string, maxLength: number): string {
 function cloneHeaders(
   headers: HeadersInit | undefined
 ): Record<string, string> {
-  return { ...headers };
+  return headers instanceof Headers
+    ? Object.fromEntries(headers.entries())
+    : Array.isArray(headers)
+    ? Object.fromEntries(headers)
+    : { ...headers };
 }
 
 async function requireLoggedIn(): Promise<void> {
@@ -83,11 +89,11 @@ async function requireLoggedIn(): Promise<void> {
 }
 
 function requireApiToken(): string {
-  const apiToken = getAPIToken();
-  if (!apiToken) {
+  const authToken = getAPIToken();
+  if (!authToken) {
     throw new Error("No API token found.");
   }
-  return apiToken;
+  return authToken;
 }
 
 function addAuthorizationHeader(

package/src/config/config.ts

@@ -20,13 +20,16 @@ import type { Environment, RawEnvironment } from "./environment";
  * - `@breaking`: the deprecation/optionality is a breaking change from wrangler 1.
  * - `@todo`: there's more work to be done (with details attached).
  */
-export type Config = ConfigFields<Environment> & Environment;
+export type Config = ConfigFields<Environment, DevConfig> & Environment;
 
-export type RawConfig = Partial<ConfigFields<RawEnvironment>> &
+export type RawConfig = Partial<ConfigFields<RawEnvironment, RawDevConfig>> &
   RawEnvironment &
   DeprecatedConfigFields;
 
-export interface ConfigFields<Env extends RawEnvironment> {
+export interface ConfigFields<
+  Env extends RawEnvironment,
+  Dev extends RawDevConfig
+> {
   configPath: string | undefined;
 
   /**
@@ -60,46 +63,8 @@ export interface ConfigFields<Env extends RawEnvironment> {
 
   /**
    * Options to configure the development server that your worker will use.
-   *
-   * @default `{}`
    */
-  dev: {
-    /**
-     * IP address for the local dev server to listen on,
-     *
-     * @default `127.0.0.1`
-     * @todo this needs to be implemented
-     */
-    ip?: string;
-
-    /**
-     * Port for the local dev server to listen on
-     *
-     * @default `8787`
-     */
-    port?: number;
-
-    /**
-     * Protocol that local wrangler dev server listens to requests on.
-     *
-     * @default `http`
-     * @todo this needs to be implemented
-     */
-    local_protocol?: string;
-
-    /**
-     * Protocol that wrangler dev forwards requests on
-     *
-     * @default `https`
-     * @todo this needs to be implemented
-     */
-    upstream_protocol?: string;
-
-    /**
-     * Host to forward requests to, defaults to the zone of project
-     */
-    host?: string;
-  };
+  dev: Dev;
 
   /**
    * A list of migrations that should be uploaded with your Worker.
@@ -209,11 +174,56 @@ export interface ConfigFields<Env extends RawEnvironment> {
     cwd?: string;
     /** The directory to watch for changes while using wrangler dev, defaults to the current working directory */
     watch_dir?: string;
-    /** Deprecated field previously used to configure the build and upload of the script. */
+    /**
+     * Deprecated field previously used to configure the build and upload of the script.
+     * @deprecated
+     */
     upload?: DeprecatedUpload;
   };
 }
 
+export interface DevConfig {
+  /**
+   * IP address for the local dev server to listen on,
+   *
+   * @default `127.0.0.1`
+   * @todo this needs to be implemented
+   */
+  ip: string;
+
+  /**
+   * Port for the local dev server to listen on
+   *
+   * @default `8787`
+   */
+  port: number;
+
+  /**
+   * Protocol that local wrangler dev server listens to requests on.
+   *
+   * @default `http`
+   * @todo this needs to be implemented
+   */
+  local_protocol: "http" | "https";
+
+  /**
+   * Protocol that wrangler dev forwards requests on
+   *
+   * Setting this to `http` is not currently implemented.
+   * See https://github.com/cloudflare/wrangler2/issues/583
+   *
+   * @default `https`
+   */
+  upstream_protocol: "https" | "http";
+
+  /**
+   * Host to forward requests to, defaults to the zone of project
+   */
+  host: string | undefined;
+}
+
+export type RawDevConfig = Partial<DevConfig>;
+
 export interface DeprecatedConfigFields {
   /**
    * The project "type". A holdover from wrangler 1.x.
@@ -252,7 +262,6 @@ export interface DeprecatedUpload {
    * Defaults to the directory containing the wrangler.toml file.
    *
    * @deprecated
-   * @breaking In wrangler 1, this defaults to ./dist, whereas in wrangler 2 it defaults to ./
    */
   dir?: string;
 

package/src/config/validation-helpers.ts

@@ -5,7 +5,7 @@ import type { Environment, RawEnvironment } from "./environment";
 /**
  *  Mark a field as deprecated.
  *
- * This function will add a diagnostics warning if the deprecated field is found in the `rawEnv`.
+ * This function will add a diagnostics warning if the deprecated field is found in the `rawEnv` (or an error if it's also a breaking deprecation)
  * The `fieldPath` is a dot separated property path, e.g. `"build.upload.format"`.
  */
 export function deprecated<T extends object>(
@@ -13,11 +13,14 @@ export function deprecated<T extends object>(
   config: T,
   fieldPath: DeepKeyOf<T>,
   message: string,
-  remove: boolean
+  remove: boolean,
+  breaking = false
 ): void {
   const result = unwindPropertyPath(config, fieldPath);
   if (result !== undefined && result.field in result.container) {
-    diagnostics.warnings.push(`DEPRECATION: "${fieldPath}":\n${message}`);
+    (breaking ? diagnostics.errors : diagnostics.warnings).push(
+      `DEPRECATION: "${fieldPath}":\n${message}`
+    );
     if (remove) {
       delete (result.container as Record<string, unknown>)[result.field];
     }
@@ -61,6 +64,41 @@ export function inheritable<K extends keyof Environment>(
   return (rawEnv[field] as Environment[K]) ?? config?.[field] ?? defaultValue;
 }
 
+/**
+ * Get an inheritable environment field, but only if we are in legacy environments
+ */
+export function inheritableInLegacyEnvironments<K extends keyof Environment>(
+  diagnostics: Diagnostics,
+  config: Config | undefined,
+  rawEnv: RawEnvironment,
+  field: K,
+  validate: ValidatorFn,
+  defaultValue: Environment[K]
+): Environment[K] {
+  return config === undefined || config.legacy_env
+    ? inheritable(diagnostics, config, rawEnv, field, validate, defaultValue)
+    : notAllowedInNamedServiceEnvironment(diagnostics, config, rawEnv, field);
+}
+
+/**
+ * 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,
+  config: Config,
+  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 config[field];
+}
+
 /**
  * Get a not inheritable environment field, after computing and validating its value.
  *
@@ -202,15 +240,60 @@ export const isOneOf =
   (diagnostics, field, value) => {
     if (value !== undefined && !choices.some((choice) => value === choice)) {
       diagnostics.errors.push(
-        `Expected "${field}" field to be on of ${choices} but got ${JSON.stringify(
-          value
-        )}.`
+        `Expected "${field}" field to be one of ${JSON.stringify(
+          choices
+        )} but got ${JSON.stringify(value)}.`
       );
       return false;
     }
     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 ${JSON.stringify([field, ...fields])}.`
+        );
+        return false;
+      }
+    }
+
+    return true;
+  };
+};
+
 /**
  * Validate that the field is a boolean.
  */
@@ -234,21 +317,28 @@ export const validateRequiredProperty = (
   container: string,
   key: string,
   value: unknown,
-  type: string
+  type: string,
+  choices?: unknown[]
 ): boolean => {
   if (container) {
     container += ".";
   }
   if (value === undefined) {
-    diagnostics.errors.push(`ERROR: "${container}${key}" is a required field.`);
+    diagnostics.errors.push(`"${container}${key}" is a required field.`);
     return false;
   } else if (typeof value !== type) {
     diagnostics.errors.push(
-      `ERROR: "${container}${key}" should be of type ${type} but got ${JSON.stringify(
+      `Expected "${container}${key}" to be of type ${type} but got ${JSON.stringify(
         value
       )}.`
     );
     return false;
+  } else if (choices) {
+    if (
+      !isOneOf(...choices)(diagnostics, `${container}${key}`, value, undefined)
+    ) {
+      return false;
+    }
   }
   return true;
 };
@@ -261,10 +351,18 @@ export const validateOptionalProperty = (
   container: string,
   key: string,
   value: unknown,
-  type: string
+  type: string,
+  choices?: unknown[]
 ): boolean => {
   if (value !== undefined) {
-    return validateRequiredProperty(diagnostics, container, key, value, type);
+    return validateRequiredProperty(
+      diagnostics,
+      container,
+      key,
+      value,
+      type,
+      choices
+    );
   }
   return true;
 };
@@ -281,7 +379,7 @@ export const validateTypedArray = (
   let isValid = true;
   if (!Array.isArray(value)) {
     diagnostics.errors.push(
-      `"${container}" should be an array of ${type}s but got ${JSON.stringify(
+      `Expected "${container}" to be an array of ${type}s but got ${JSON.stringify(
         value
       )}`
     );