wrangler 0.0.0-e043479 → 0.0.0-e0a0509

package/src/__tests__/user.test.ts

@@ -0,0 +1,131 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import fetchMock from "jest-fetch-mock";
+import {
+  readAuthConfigFile,
+  requireAuth,
+  USER_AUTH_CONFIG_FILE,
+  writeAuthConfigFile,
+} from "../user";
+import { mockConsoleMethods } from "./helpers/mock-console";
+import { useMockIsTTY } from "./helpers/mock-istty";
+import { mockOAuthFlow } from "./helpers/mock-oauth-flow";
+import { runInTempDir } from "./helpers/run-in-tmp";
+import { runWrangler } from "./helpers/run-wrangler";
+import type { Config } from "../config";
+import type { UserAuthConfig } from "../user";
+
+describe("User", () => {
+  runInTempDir({ homedir: "./home" });
+  const std = mockConsoleMethods();
+  const {
+    mockOAuthServerCallback,
+    mockGrantAccessToken,
+    mockGrantAuthorization,
+    mockRevokeAuthorization,
+    mockExchangeRefreshTokenForAccessToken,
+  } = mockOAuthFlow();
+
+  const { setIsTTY } = useMockIsTTY();
+
+  describe("login", () => {
+    it("should login a user when `wrangler login` is run", async () => {
+      mockOAuthServerCallback();
+      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();
+    });
+  });
+
+  // TODO: Improve OAuth mocking to handle `/token` endpoints from different calls
+  it("should handle errors for failed token refresh", async () => {
+    setIsTTY(false);
+    mockOAuthServerCallback();
+    writeAuthConfigFile({
+      oauth_token: "hunter2",
+      refresh_token: "Order 66",
+    });
+    mockGrantAuthorization({ respondWith: "success" });
+
+    mockExchangeRefreshTokenForAccessToken({
+      respondWith: "badResponse",
+    });
+
+    // Handles the requireAuth error throw from failed login that is unhandled due to directly calling it here
+    await expect(
+      requireAuth({} as Config)
+    ).rejects.toThrowErrorMatchingInlineSnapshot(
+      `"Did not login, quitting..."`
+    );
+  });
+
+  it("should confirm no error message when refresh is successful", async () => {
+    setIsTTY(false);
+    mockOAuthServerCallback();
+    writeAuthConfigFile({
+      oauth_token: "hunter2",
+      refresh_token: "Order 66",
+    });
+    mockGrantAuthorization({ respondWith: "success" });
+
+    mockExchangeRefreshTokenForAccessToken({
+      respondWith: "refreshSuccess",
+    });
+
+    // Handles the requireAuth error throw from failed login that is unhandled due to directly calling it here
+    await expect(requireAuth({} as Config)).rejects.toThrowError();
+    expect(std.err).toContain("");
+  });
+});

package/src/__tests__/whoami.test.tsx

@@ -1,30 +1,36 @@
 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 { 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 () => {
-    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 +42,6 @@ describe("getUserInfo()", () => {
       ];
     });
 
-    await initialise();
     const userInfo = await getUserInfo();
 
     expect(userInfo).toEqual({
@@ -50,6 +55,20 @@ 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(`
+      "▲ [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.
+
+      "
+    `);
+  });
 });
 
 describe("WhoAmI component", () => {

package/src/bundle.ts

@@ -1,11 +1,13 @@
 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 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,38 +26,72 @@ export async function bundleWorker(
     serveAssetsFromWorker: boolean;
     jsxFactory: string | undefined;
     jsxFragment: string | undefined;
-    format: CfScriptFormat;
     rules: Config["rules"];
     watch?: esbuild.WatchMode;
+    tsconfig: string | undefined;
+    minify: boolean | undefined;
+    nodeCompat: boolean | undefined;
   }
 ): Promise<BundleResult> {
   const {
     serveAssetsFromWorker,
     jsxFactory,
     jsxFragment,
-    format,
     rules,
     watch,
+    tsconfig,
+    minify,
+    nodeCompat,
   } = options;
-  const moduleCollector = makeModuleCollector({ format, rules });
+  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,
+  });
   const result = await esbuild.build({
     ...getEntryPoint(entry.file, serveAssetsFromWorker),
     bundle: true,
     absWorkingDir: entry.directory,
     outdir: destination,
     external: ["__STATIC_CONTENT_MANIFEST"],
-    format: "esm",
+    format: entry.format === "modules" ? "esm" : "iife",
+    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,4 +1,4 @@
-import { fetch } from "undici";
+import { fetch, Headers } from "undici";
 import { getEnvironmentVariableFactory } from "../environment-variables";
 import { ParseError, parseJSON } from "../parse";
 import { getAPIToken, loginOrRefreshIfRequired } from "../user";
@@ -72,7 +72,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 +87,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/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

@@ -25,31 +25,30 @@ 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
 - 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.
@@ -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,20 +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<DevConfig> & Environment;
 
-export type RawConfig = Partial<ConfigFields<RawEnvironment>> &
+export type RawConfig = Partial<ConfigFields<RawDevConfig>> &
   RawEnvironment &
-  DeprecatedConfigFields;
+  DeprecatedConfigFields &
+  EnvironmentMap;
 
-export interface ConfigFields<Env extends RawEnvironment> {
+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
@@ -42,64 +38,10 @@ export interface ConfigFields<Env extends RawEnvironment> {
    */
   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.
-   *
-   * @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.
@@ -195,25 +137,58 @@ export interface ConfigFields<Env extends RawEnvironment> {
     | undefined;
 
   /**
-   * Configures a custom build step to be run by Wrangler when building your Worker.
+   * 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 {
+  /**
+   * IP address for the local dev server to listen on,
    *
-   * Refer to the [custom builds documentation](https://developers.cloudflare.com/workers/cli-wrangler/configuration#build)
-   * for more details.
+   * @default `localhost`
+   */
+  ip: string;
+
+  /**
+   * Port for the local dev server to listen on
    *
-   * @default {}
+   * @default `8787`
    */
-  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. */
-    upload?: DeprecatedUpload;
-  };
+  port: number | undefined;
+
+  /**
+   * Protocol that local wrangler dev server listens to requests on.
+   *
+   * @default `http`
+   */
+  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`
+   * @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 host of the first route of project
+   */
+  host: Config["route"];
 }
 
+export type RawDevConfig = Partial<DevConfig>;
+
 export interface DeprecatedConfigFields {
   /**
    * The project "type". A holdover from wrangler 1.x.
@@ -232,39 +207,28 @@ export interface DeprecatedConfigFields {
    * @breaking
    */
   webpack_config?: string;
-}
 
-/**
- * Deprecated upload configuration.
- */
-export interface DeprecatedUpload {
   /**
-   * The format of the Worker script.
-   *
-   * @deprecated We infer the format automatically now.
+   * Configuration only used by a standalone use of the miniflare binary.
+   * @deprecated
    */
-  format?: "modules" | "service-worker";
+  miniflare?: unknown;
+}
 
+interface EnvironmentMap {
   /**
-   * The directory you wish to upload your worker from,
-   * relative to the wrangler.toml file.
+   * The `env` section defines overrides for the configuration for different environments.
    *
-   * Defaults to the directory containing the wrangler.toml file.
+   * All environment fields can be specified at the top level of the config indicating the default environment settings.
    *
-   * @deprecated
-   * @breaking In wrangler 1, this defaults to ./dist, whereas in wrangler 2 it defaults to ./
-   */
-  dir?: string;
-
-  /**
-   * The path to the Worker script, relative to `upload.dir`.
+   * - 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 This will be replaced by a command line argument.
-   */
-  main?: string;
-
-  /**
-   * @deprecated This is now defined at the top level `rules` field.
+   * For more information, see the documentation at https://developers.cloudflare.com/workers/cli-wrangler/configuration#environments
+   *
+   * @default `{}`
    */
-  rules?: Environment["rules"];
+  env?: {
+    [envName: string]: RawEnvironment;
+  };
 }