wrangler 0.0.0-e95bea2 → 0.0.0-ea8e701

package/src/__tests__/r2.test.ts

@@ -90,7 +90,7 @@ describe("wrangler", () => {
           await expect(
             runWrangler("r2 bucket create abc def ghi")
           ).rejects.toThrowErrorMatchingInlineSnapshot(
-            `"Unexpected additional positional arguments \\"def ghi\\"."`
+            `"Unknown arguments: def, ghi"`
           );
           expect(std.out).toMatchInlineSnapshot(`""`);
           expect(std.err).toMatchInlineSnapshot(`
@@ -107,7 +107,7 @@ describe("wrangler", () => {
               -v, --version     Show version number  [boolean]
                   --legacy-env  Use legacy environments  [boolean]
 
-            Unexpected additional positional arguments \\"def ghi\\"."
+            Unknown arguments: def, ghi"
           `);
         });
 
@@ -166,7 +166,7 @@ describe("wrangler", () => {
           await expect(
             runWrangler("r2 bucket delete abc def ghi")
           ).rejects.toThrowErrorMatchingInlineSnapshot(
-            `"Unexpected additional positional arguments \\"def ghi\\"."`
+            `"Unknown arguments: def, ghi"`
           );
           expect(std.out).toMatchInlineSnapshot(`""`);
           expect(std.err).toMatchInlineSnapshot(`
@@ -183,7 +183,7 @@ describe("wrangler", () => {
               -v, --version     Show version number  [boolean]
                   --legacy-env  Use legacy environments  [boolean]
 
-            Unexpected additional positional arguments \\"def ghi\\"."
+            Unknown arguments: def, ghi"
           `);
         });
 

package/src/__tests__/tail.test.ts

@@ -134,7 +134,7 @@ describe("tail", () => {
 
     it("sends header filters without a query", async () => {
       const api = mockWebsocketAPIs();
-      await runWrangler("tail test-worker --header X-CUSTOM-HEADER ");
+      await runWrangler("tail test-worker --header X-CUSTOM-HEADER");
       await expect(api.nextMessageJson()).resolves.toHaveProperty("filters", [
         { header: { key: "X-CUSTOM-HEADER" } },
       ]);
@@ -142,9 +142,7 @@ describe("tail", () => {
 
     it("sends header filters with a query", async () => {
       const api = mockWebsocketAPIs();
-      await runWrangler(
-        "tail test-worker --header X-CUSTOM-HEADER:some-value "
-      );
+      await runWrangler("tail test-worker --header X-CUSTOM-HEADER:some-value");
       await expect(api.nextMessageJson()).resolves.toHaveProperty("filters", [
         { header: { key: "X-CUSTOM-HEADER", query: "some-value" } },
       ]);
@@ -268,6 +266,82 @@ describe("tail", () => {
       `);
     });
 
+    it("defaults to logging in pretty format", async () => {
+      // the same test as the one before, but without the --format flag
+      const api = mockWebsocketAPIs();
+      await runWrangler("tail test-worker");
+
+      const event = generateMockRequestEvent();
+      const message = generateMockEventMessage({ event });
+      const serializedMessage = serialize(message);
+
+      api.ws.send(serializedMessage);
+      expect(
+        std.out
+          .replace(
+            new Date(mockEventTimestamp).toLocaleString(),
+            "[mock event timestamp]"
+          )
+          .replace(
+            mockTailExpiration.toLocaleString(),
+            "[mock expiration date]"
+          )
+      ).toMatchInlineSnapshot(`
+        "successfully created tail, expires at [mock expiration date]
+        Connected to test-worker, waiting for logs...
+        GET https://example.org/ - Ok @ [mock event timestamp]"
+      `);
+    });
+
+    it("logs console messages and exceptions", async () => {
+      const api = mockWebsocketAPIs();
+      await runWrangler("tail test-worker");
+
+      const event = generateMockRequestEvent();
+      const message = generateMockEventMessage({
+        event,
+        logs: [
+          { message: ["some string"], level: "log", timestamp: 1234561 },
+          {
+            message: [{ complex: "object" }],
+            level: "log",
+            timestamp: 1234562,
+          },
+          { message: [1234], level: "error", timestamp: 1234563 },
+        ],
+        exceptions: [
+          { name: "Error", message: "some error", timestamp: 1234564 },
+          { name: "Error", message: { complex: "error" }, timestamp: 1234564 },
+        ],
+      });
+      const serializedMessage = serialize(message);
+
+      api.ws.send(serializedMessage);
+      expect(
+        std.out
+          .replace(
+            new Date(mockEventTimestamp).toLocaleString(),
+            "[mock event timestamp]"
+          )
+          .replace(
+            mockTailExpiration.toLocaleString(),
+            "[mock expiration date]"
+          )
+      ).toMatchInlineSnapshot(`
+        "successfully created tail, expires at [mock expiration date]
+        Connected to test-worker, waiting for logs...
+        GET https://example.org/ - Ok @ [mock event timestamp]
+          (log) some string
+          (log) { complex: 'object' }
+          (error) 1234"
+      `);
+      expect(std.err).toMatchInlineSnapshot(`
+        "  Error: some error
+          Error: { complex: 'error' }"
+      `);
+      expect(std.warn).toMatchInlineSnapshot(`""`);
+    });
+
     it("logs scheduled messages in pretty format", async () => {
       const api = mockWebsocketAPIs();
       await runWrangler("tail test-worker --format pretty");

package/src/__tests__/user.test.ts

@@ -0,0 +1,83 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import fetchMock from "jest-fetch-mock";
+import {
+  readAuthConfigFile,
+  USER_AUTH_CONFIG_FILE,
+  writeAuthConfigFile,
+} from "../user";
+import { mockConsoleMethods } from "./helpers/mock-console";
+import { mockOAuthFlow } from "./helpers/mock-oauth-flow";
+import { runInTempDir } from "./helpers/run-in-tmp";
+import { runWrangler } from "./helpers/run-wrangler";
+import type { UserAuthConfig } from "../user";
+
+describe("wrangler", () => {
+  runInTempDir({ homedir: "./home" });
+  const std = mockConsoleMethods();
+  const {
+    mockGrantAccessToken,
+    mockGrantAuthorization,
+    mockRevokeAuthorization,
+  } = mockOAuthFlow();
+
+  describe("login", () => {
+    it("should should log in a user when `wrangler login` is run", async () => {
+      const accessTokenRequest = mockGrantAccessToken({ respondWith: "ok" });
+      mockGrantAuthorization({ respondWith: "success" });
+
+      await runWrangler("login");
+
+      expect(accessTokenRequest.actual.url).toEqual(
+        accessTokenRequest.expected.url
+      );
+      expect(accessTokenRequest.actual.method).toEqual(
+        accessTokenRequest.expected.method
+      );
+
+      expect(std.out).toMatchInlineSnapshot(`
+        "Attempting to login via OAuth...
+        Successfully logged in."
+      `);
+
+      expect(readAuthConfigFile()).toEqual<UserAuthConfig>({
+        api_token: undefined,
+        oauth_token: "test-access-token",
+        refresh_token: "test-refresh-token",
+        expiration_time: expect.any(String),
+      });
+    });
+  });
+
+  describe("logout", () => {
+    it("should exit with a message stating the user is not logged in", async () => {
+      await runWrangler("logout");
+      expect(std.out).toMatchInlineSnapshot(`"Not logged in, exiting..."`);
+    });
+
+    it("should logout user that has been properly logged in", async () => {
+      writeAuthConfigFile({
+        oauth_token: "some-oauth-tok",
+        refresh_token: "some-refresh-tok",
+      });
+      const outcome = mockRevokeAuthorization();
+
+      await runWrangler("logout");
+
+      expect(outcome.actual.url).toEqual(
+        "https://dash.cloudflare.com/oauth2/revoke"
+      );
+      expect(outcome.actual.method).toEqual("POST");
+
+      expect(std.out).toMatchInlineSnapshot(`"Successfully logged out."`);
+
+      // Make sure that we made the request to logout.
+      expect(fetchMock).toHaveBeenCalledTimes(1);
+
+      // Make sure that logout removed the config file containing the auth tokens.
+      const config = path.join(os.homedir(), USER_AUTH_CONFIG_FILE);
+      expect(fs.existsSync(config)).toBeFalsy();
+    });
+  });
+});

package/src/__tests__/whoami.test.tsx

@@ -1,30 +1,30 @@
 import { render } from "ink-testing-library";
 import React from "react";
-import { initialise } from "../user";
+import { 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({});
     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" });
+
     setMockResponse("/user", () => {
       return { email: "user@example.com" };
     });
@@ -36,7 +36,6 @@ describe("getUserInfo()", () => {
       ];
     });
 
-    await initialise();
     const userInfo = await getUserInfo();
 
     expect(userInfo).toEqual({
@@ -50,6 +49,16 @@ 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 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

@@ -26,10 +26,17 @@ export async function bundleWorker(
     jsxFragment: string | undefined;
     rules: Config["rules"];
     watch?: esbuild.WatchMode;
+    tsconfig: string | undefined;
   }
 ): Promise<BundleResult> {
-  const { serveAssetsFromWorker, jsxFactory, jsxFragment, rules, watch } =
-    options;
+  const {
+    serveAssetsFromWorker,
+    jsxFactory,
+    jsxFragment,
+    rules,
+    watch,
+    tsconfig,
+  } = options;
   const entryDirectory = path.dirname(entry.file);
   const moduleCollector = createModuleCollector({
     wrangler1xlegacyModuleReferences: {
@@ -57,6 +64,11 @@ export async function bundleWorker(
     sourcemap: true,
     metafile: true,
     conditions: ["worker", "browser"],
+    ...(process.env.NODE_ENV && {
+      define: {
+        "process.env.NODE_ENV": `"${process.env.NODE_ENV}"`,
+      },
+    }),
     loader: {
       ".js": "jsx",
       ".mjs": "jsx",
@@ -65,6 +77,7 @@ export async function bundleWorker(
     plugins: [moduleCollector.plugin],
     ...(jsxFactory && { jsxFactory }),
     ...(jsxFragment && { jsxFragment }),
+    ...(tsconfig && { tsconfig }),
     watch,
   });
 

package/src/cfetch/internal.ts

@@ -1,4 +1,4 @@
-import { fetch } from "undici";
+import { fetch, Headers } from "undici";
 import { getEnvironmentVariableFactory } from "../environment-variables";
 import { ParseError, parseJSON } from "../parse";
 import { reportError } from "../reporting";
@@ -74,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> {
@@ -85,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/README.md

@@ -25,24 +25,23 @@ This includes the `EnvironmentInheritable` and `EnvironmentNonInheritable` field
 ### Config
 
 The "non-overridable" types are defined in the [`ConfigFields`](./config.ts) type.
-Notably this also contains a property called `env` which is the container for the named environment configuration.
-
 The `Config` type is the overall configuration, which consists of the `ConfigFields` and also an `Environment`.
-In this case the `Environment`, here, corresponds to the top level environment.
+In this case the `Environment`, here, corresponds to the "currently active" environment. This is specified by the `--env` command line argument.
+If there is no argument passed then the currently active environment is the "top-level" environment.
 The fields in `Config` and `Environment` are not generally optional and so you can expect they have been filled with suitable inherited or default values.
 These types should be used when you are working with fields that should be passed to commands.
 
 ### RawConfig
 
 The `RawConfig` type is a version of `Config`, where all the fields are optional.
-The `RawConfig` type also includes `DeprecatedConfigFields` and extends and contains the `RawEnvironment` type,
-which is a version of `Environment` where all the fields are optional.
+The `RawConfig` type includes `DeprecatedConfigFields` and `EnvironmentMap`.
+It also extends the `RawEnvironment` type, which is a version of `Environment` where all the fields are optional.
 These optional fields map to the actual fields found in the `wrangler.toml`.
 These types should be used when you are working with raw configuration that is read or will be written to a `wrangler.toml`.
 
 ## Validation
 
-Validation is triggered by passing a `RawConfig` object to the `normalizeAndValidateConfig()` function.
+Validation is triggered by passing a `RawConfig` object, and the active environment name, to the `normalizeAndValidateConfig()` function.
 This function will return:
 
 - a `Config` object, where all the fields have suitable valid values
@@ -62,6 +61,7 @@ The [high level API](./index.ts) for configuration processing consists of the `f
 ### readConfig()
 
 The `readConfig()` function will find the nearest `wrangler.toml` file, load and parse it, then validate and normalize the values into a `Config` object.
+Note that you should pass the current active environment name in as a parameter. The resulting `Config` object will contain only the fields appropriate to that environment.
 If there are validation errors then it will throw a suitable error.
 
 ## Changing configuration

package/src/config/config.ts

@@ -3,7 +3,7 @@ import type { Environment, RawEnvironment } from "./environment";
 /**
  * This is the static type definition for the configuration object.
  *
- * It reflects the configuration that you can write in wrangler.toml,
+ * It reflects a normalized and validated version of the configuration that you can write in wrangler.toml,
  * and optionally augment with arguments passed directly to wrangler.
  *
  * For more information about the configuration object, see the
@@ -20,23 +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, DevConfig> & Environment;
+export type Config = ConfigFields<DevConfig> & Environment;
 
-export type RawConfig = Partial<ConfigFields<RawEnvironment, RawDevConfig>> &
+export type RawConfig = Partial<ConfigFields<RawDevConfig>> &
   RawEnvironment &
-  DeprecatedConfigFields;
+  DeprecatedConfigFields &
+  EnvironmentMap;
 
-export interface ConfigFields<
-  Env extends RawEnvironment,
-  Dev extends RawDevConfig
-> {
+export interface ConfigFields<Dev extends RawDevConfig> {
   configPath: string | undefined;
 
-  /**
-   * The entrypoint/path to the JavaScript file that will be executed.
-   */
-  main: string | undefined;
-
   /**
    * A boolean to enable "legacy" style wrangler environments (from wrangler 1).
    * These have been superseded by Services, but there may be projects that won't
@@ -45,22 +38,6 @@ export interface ConfigFields<
    */
   legacy_env: boolean;
 
-  /**
-   * The `env` section defines overrides for the configuration for different environments.
-   *
-   * All environment fields can be specified at the top level of the config indicating the default environment settings.
-   *
-   * - Some fields are inherited and overridable in each environment.
-   * - But some are not inherited and must be explicitly specified in every environment, if they are specified at the top level.
-   *
-   * For more information, see the documentation at https://developers.cloudflare.com/workers/cli-wrangler/configuration#environments
-   *
-   * @default `{}`
-   */
-  env: {
-    [envName: string]: Env;
-  };
-
   /**
    * Options to configure the development server that your worker will use.
    */
@@ -158,35 +135,13 @@ export interface ConfigFields<
         [key: string]: string;
       }
     | undefined;
-
-  /**
-   * Configures a custom build step to be run by Wrangler when building your Worker.
-   *
-   * Refer to the [custom builds documentation](https://developers.cloudflare.com/workers/cli-wrangler/configuration#build)
-   * for more details.
-   *
-   * @default {}
-   */
-  build: {
-    /** The command used to build your Worker. On Linux and macOS, the command is executed in the `sh` shell and the `cmd` shell for Windows. The `&&` and `||` shell operators may be used. */
-    command?: string;
-    /** 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;
-    /**
-     * 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`
+   * @default `localhost`
    * @todo this needs to be implemented
    */
   ip: string;
@@ -244,36 +199,20 @@ export interface DeprecatedConfigFields {
   webpack_config?: string;
 }
 
-/**
- * Deprecated upload configuration.
- */
-export interface DeprecatedUpload {
+interface EnvironmentMap {
   /**
-   * The format of the Worker script.
+   * The `env` section defines overrides for the configuration for different environments.
    *
-   * @deprecated We infer the format automatically now.
-   */
-  format?: "modules" | "service-worker";
-
-  /**
-   * The directory you wish to upload your worker from,
-   * relative to the wrangler.toml file.
+   * All environment fields can be specified at the top level of the config indicating the default environment settings.
    *
-   * Defaults to the directory containing the wrangler.toml file.
+   * - Some fields are inherited and overridable in each environment.
+   * - But some are not inherited and must be explicitly specified in every environment, if they are specified at the top level.
    *
-   * @deprecated
-   */
-  dir?: string;
-
-  /**
-   * The path to the Worker script, relative to `upload.dir`.
+   * For more information, see the documentation at https://developers.cloudflare.com/workers/cli-wrangler/configuration#environments
    *
-   * @deprecated This will be replaced by a command line argument.
-   */
-  main?: string;
-
-  /**
-   * @deprecated This is now defined at the top level `rules` field.
+   * @default `{}`
    */
-  rules?: Environment["rules"];
+  env?: {
+    [envName: string]: RawEnvironment;
+  };
 }

package/src/config/environment.ts

@@ -51,6 +51,11 @@ interface EnvironmentInheritable {
    */
   compatibility_flags: string[];
 
+  /**
+   * The entrypoint/path to the JavaScript file that will be executed.
+   */
+  main: string | undefined;
+
   /**
    * Whether we use <name>.<subdomain>.workers.dev to
    * test and deploy your worker.
@@ -59,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.
@@ -82,6 +87,11 @@ interface EnvironmentInheritable {
    */
   route: string | undefined;
 
+  /**
+   * Path to a custom tsconfig
+   */
+  tsconfig: string | undefined;
+
   /**
    * The function to use to replace jsx syntax.
    *
@@ -133,6 +143,28 @@ interface EnvironmentInheritable {
    */
   rules: Rule[];
 
+  /**
+   * Configures a custom build step to be run by Wrangler when building your Worker.
+   *
+   * Refer to the [custom builds documentation](https://developers.cloudflare.com/workers/cli-wrangler/configuration#build)
+   * for more details.
+   *
+   * @default {}
+   */
+  build: {
+    /** The command used to build your Worker. On Linux and macOS, the command is executed in the `sh` shell and the `cmd` shell for Windows. The `&&` and `||` shell operators may be used. */
+    command?: string;
+    /** 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;
+    /**
+     * Deprecated field previously used to configure the build and upload of the script.
+     * @deprecated
+     */
+    upload?: DeprecatedUpload;
+  };
+
   /**
    * TODO: remove this as it has been deprecated.
    *
@@ -277,6 +309,40 @@ interface EnvironmentDeprecated {
   }[];
 }
 
+/**
+ * Deprecated upload configuration.
+ */
+export interface DeprecatedUpload {
+  /**
+   * The format of the Worker script.
+   *
+   * @deprecated We infer the format automatically now.
+   */
+  format?: "modules" | "service-worker";
+
+  /**
+   * The directory you wish to upload your worker from,
+   * relative to the wrangler.toml file.
+   *
+   * Defaults to the directory containing the wrangler.toml file.
+   *
+   * @deprecated
+   */
+  dir?: string;
+
+  /**
+   * The path to the Worker script, relative to `upload.dir`.
+   *
+   * @deprecated This will be replaced by a command line argument.
+   */
+  main?: string;
+
+  /**
+   * @deprecated This is now defined at the top level `rules` field.
+   */
+  rules?: Environment["rules"];
+}
+
 /**
  * The raw environment configuration that we read from the config file.
  *

package/src/config/index.ts

@@ -3,7 +3,13 @@ import { parseTOML, readFileSync } from "../parse";
 import { normalizeAndValidateConfig } from "./validation";
 import type { Config, RawConfig } from "./config";
 
-export type { Config, RawConfig } from "./config";
+export type {
+  Config,
+  RawConfig,
+  ConfigFields,
+  DevConfig,
+  RawDevConfig,
+} from "./config";
 export type {
   Environment,
   RawEnvironment,
@@ -13,7 +19,10 @@ export type {
 /**
  * Get the Wrangler configuration; read it from the give `configPath` if available.
  */
-export function readConfig(configPath?: string): Config {
+export function readConfig(
+  configPath: string | undefined,
+  args: unknown
+): Config {
   let rawConfig: RawConfig = {};
   if (!configPath) {
     configPath = findWranglerToml();
@@ -27,7 +36,8 @@ export function readConfig(configPath?: string): Config {
   // Process the top-level configuration.
   const { config, diagnostics } = normalizeAndValidateConfig(
     rawConfig,
-    configPath
+    configPath,
+    args
   );
 
   if (diagnostics.hasWarnings()) {