wrangler 0.0.0-e3cab74 → 0.0.0-e3ce82b

package/src/__tests__/tail.test.ts

@@ -3,6 +3,7 @@ import { Headers, Request } from "undici";
 import { mockAccountId, mockApiToken } from "./helpers/mock-account-id";
 import { setMockResponse, unsetAllMocks } from "./helpers/mock-cfetch";
 import { mockConsoleMethods } from "./helpers/mock-console";
+import { useMockIsTTY } from "./helpers/mock-istty";
 import { runInTempDir } from "./helpers/run-in-tmp";
 import { runWrangler } from "./helpers/run-wrangler";
 import type { TailEventMessage, RequestEvent, ScheduledEvent } from "../tail";
@@ -134,7 +135,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 +143,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" } },
       ]);
@@ -218,6 +217,8 @@ describe("tail", () => {
   });
 
   describe("printing", () => {
+    const { setIsTTY } = useMockIsTTY();
+
     it("logs request messages in JSON format", async () => {
       const api = mockWebsocketAPIs();
       await runWrangler("tail test-worker --format json");
@@ -262,7 +263,7 @@ describe("tail", () => {
             "[mock expiration date]"
           )
       ).toMatchInlineSnapshot(`
-        "successfully created tail, expires at [mock expiration date]
+        "Successfully created tail, expires at [mock expiration date]
         Connected to test-worker, waiting for logs...
         GET https://example.org/ - Ok @ [mock event timestamp]"
       `);
@@ -288,11 +289,131 @@ describe("tail", () => {
             "[mock expiration date]"
           )
       ).toMatchInlineSnapshot(`
-        "successfully created tail, expires at [mock expiration date]
+        "Successfully created tail, expires at [mock expiration date]
         Connected to test-worker, waiting for logs...
         \\"* * * * *\\" @ [mock timestamp string] - Ok"
       `);
     });
+
+    it("should not crash when the tail message has a void event", async () => {
+      const api = mockWebsocketAPIs();
+      await runWrangler("tail test-worker --format pretty");
+
+      const message = generateMockEventMessage({ event: null });
+      const serializedMessage = serialize(message);
+
+      api.ws.send(serializedMessage);
+      expect(
+        std.out
+          .replace(
+            new Date(mockEventTimestamp).toLocaleString(),
+            "[mock timestamp string]"
+          )
+          .replace(
+            mockTailExpiration.toLocaleString(),
+            "[mock expiration date]"
+          )
+      ).toMatchInlineSnapshot(`
+        "Successfully created tail, expires at [mock expiration date]
+        Connected to test-worker, waiting for logs...
+        [missing request] - Ok @ [mock timestamp string]"
+      `);
+    });
+
+    it("defaults to logging in pretty format when the output is a TTY", async () => {
+      setIsTTY(true);
+      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("defaults to logging in json format when the output is not a TTY", async () => {
+      setIsTTY(false);
+
+      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).toMatch(deserializeToJson(serializedMessage));
+    });
+
+    it("logs console messages and exceptions", async () => {
+      setIsTTY(true);
+      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(`
+        "X [ERROR]   Error: some error
+
+
+        X [ERROR]   Error: { complex: 'error' }
+
+        "
+      `);
+      expect(std.warn).toMatchInlineSnapshot(`""`);
+    });
   });
 });
 
@@ -318,7 +439,8 @@ function serialize(message: TailEventMessage): WebSocket.RawData {
     // This isn't a problem outside of testing since deserialization
     // works just fine and wrangler never _sends_ any event messages,
     // it only receives them.
-    const request = (message.event as RequestEvent).request;
+    const request = ((message.event as RequestEvent | undefined | null) || {})
+      .request;
     const stringified = JSON.stringify(message, (key, value) => {
       if (key !== "request") {
         return value;
@@ -326,9 +448,9 @@ function serialize(message: TailEventMessage): WebSocket.RawData {
 
       return {
         ...request,
-        url: request.url,
-        headers: request.headers,
-        method: request.method,
+        url: request?.url,
+        headers: request?.headers,
+        method: request?.method,
       };
     });
 
@@ -343,9 +465,9 @@ function serialize(message: TailEventMessage): WebSocket.RawData {
  * @returns whether event is a ScheduledEvent (true) or a RequestEvent
  */
 function isScheduled(
-  event: ScheduledEvent | RequestEvent
+  event: ScheduledEvent | RequestEvent | undefined | null
 ): event is ScheduledEvent {
-  return "cron" in event;
+  return Boolean(event && "cron" in event);
 }
 
 /**
@@ -511,15 +633,19 @@ function mockWebsocketAPIs(env?: string, legacyEnv = false): MockAPI {
  * @param opts Any specific parts of the message to use instead of defaults
  * @returns a `TailEventMessage` that wrangler can process and display
  */
-function generateMockEventMessage(
-  opts?: Partial<TailEventMessage>
-): TailEventMessage {
+function generateMockEventMessage({
+  outcome = "ok",
+  exceptions = [],
+  logs = [],
+  eventTimestamp = mockEventTimestamp,
+  event = generateMockRequestEvent(),
+}: Partial<TailEventMessage>): TailEventMessage {
   return {
-    outcome: opts?.outcome || "ok",
-    exceptions: opts?.exceptions || [],
-    logs: opts?.logs || [],
-    eventTimestamp: opts?.eventTimestamp || mockEventTimestamp,
-    event: opts?.event || generateMockRequestEvent(),
+    outcome,
+    exceptions,
+    logs,
+    eventTimestamp,
+    event,
   };
 }
 

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,70 @@
 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()", () => {
+  const ENV_COPY = process.env;
+
   runInTempDir({ homedir: "./home" });
+  const std = mockConsoleMethods();
+  const { setIsTTY } = useMockIsTTY();
+
+  beforeEach(() => {
+    setIsTTY(true);
+  });
+
+  afterEach(() => {
+    process.env = ENV_COPY;
+  });
 
   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 say it's using an API token when one is set", async () => {
+    process.env = {
+      CLOUDFLARE_API_TOKEN: "123456789",
+    };
+    setMockResponse("/user", () => {
+      return { email: "user@example.com" };
+    });
+    setMockResponse("/accounts", () => {
+      return [
+        { name: "Account One", id: "account-1" },
+        { name: "Account Two", id: "account-2" },
+        { name: "Account Three", id: "account-3" },
+      ];
+    });
+
+    const userInfo = await getUserInfo();
+    expect(userInfo).toEqual({
+      authType: "API",
+      apiToken: "123456789",
+      email: "user@example.com",
+      accounts: [
+        { name: "Account One", id: "account-1" },
+        { name: "Account Two", id: "account-2" },
+        { name: "Account Three", id: "account-3" },
+      ],
+    });
+  });
+
   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 +76,6 @@ describe("getUserInfo()", () => {
       ];
     });
 
-    await initialise();
     const userInfo = await getUserInfo();
 
     expect(userInfo).toEqual({
@@ -50,6 +89,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/abort.d.ts

@@ -0,0 +1,3 @@
+declare interface AbortSignal {
+  addEventListener(event: "abort", handler: () => void);
+}

package/src/bundle.ts

@@ -1,11 +1,14 @@
 import assert from "node:assert";
 import * as fs from "node:fs";
+import { builtinModules } from "node:module";
 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[];
@@ -14,6 +17,33 @@ type BundleResult = {
   stop: (() => void) | undefined;
 };
 
+/**
+ * Searches for any uses of node's builtin modules, and throws an error if it
+ * finds anything. This plugin is only used when nodeCompat is not enabled.
+ * Supports both regular node builtins, and the new "node:<MODULE>" format.
+ */
+const checkForNodeBuiltinsPlugin = {
+  name: "checkForNodeBuiltins",
+  setup(build: esbuild.PluginBuild) {
+    build.onResolve(
+      {
+        filter: new RegExp(
+          "^(" +
+            builtinModules.join("|") +
+            "|" +
+            builtinModules.map((module) => "node:" + module).join("|") +
+            ")$"
+        ),
+      },
+      () => {
+        throw new Error(
+          `Detected a Node builtin module import while Node compatibility is disabled.\nAdd node_compat = true to your wrangler.toml file to enable Node compatibility.`
+        );
+      }
+    );
+  },
+};
+
 /**
  * Generate a bundle for the worker identified by the arguments passed in.
  */
@@ -24,38 +54,75 @@ 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()]
+        : // we use checkForNodeBuiltinsPlugin to throw a nicer error
+          // if we find node builtins when nodeCompat isn't turned on
+          [checkForNodeBuiltinsPlugin]),
+    ],
     ...(jsxFactory && { jsxFactory }),
     ...(jsxFragment && { jsxFragment }),
+    ...(tsconfig && { tsconfig }),
     watch,
   });
 
@@ -87,9 +154,7 @@ export async function bundleWorker(
   };
 }
 
-type EntryPoint =
-  | { stdin: esbuild.StdinOptions; nodePaths: string[] }
-  | { entryPoints: string[] };
+type EntryPoint = { stdin: esbuild.StdinOptions } | { entryPoints: string[] };
 
 /**
  * Create an object that describes the entry point for esbuild.
@@ -114,7 +179,6 @@ function getEntryPoint(
         sourcefile: "static-asset-facade.js",
         resolveDir: path.dirname(entryFile),
       },
-      nodePaths: [path.join(__dirname, "../vendor")],
     };
   } else {
     return { entryPoints: [entryFile] };

package/src/cfetch/index.ts

@@ -10,6 +10,7 @@ export { getCloudflareAPIBaseURL as getCloudflareApiBaseUrl } from "./internal";
 export interface FetchError {
   code: number;
   message: string;
+  error_chain?: FetchError[];
 }
 export interface FetchResult<ResponseType = unknown> {
   success: boolean;
@@ -27,12 +28,14 @@ export { fetchKVGetValue } from "./internal";
 export async function fetchResult<ResponseType>(
   resource: string,
   init: RequestInit = {},
-  queryParams?: URLSearchParams
+  queryParams?: URLSearchParams,
+  abortSignal?: AbortSignal
 ): Promise<ResponseType> {
   const json = await fetchInternal<FetchResult<ResponseType>>(
     resource,
     init,
-    queryParams
+    queryParams,
+    abortSignal
   );
   if (json.success) {
     return json.result;
@@ -83,9 +86,9 @@ function throwFetchError(
   response: FetchResult<unknown>
 ): never {
   const error = new ParseError({
-    text: "Received a bad response from the API",
+    text: `A request to the Cloudflare API (${resource}) failed.`,
     notes: response.errors.map((err) => ({
-      text: err.code ? `${err.message} [code: ${err.code}]` : err.message,
+      text: renderError(err),
     })),
   });
   // add the first error code directly to this error
@@ -102,3 +105,17 @@ function hasCursor(result_info: unknown): result_info is { cursor: string } {
   const cursor = (result_info as { cursor: string } | undefined)?.cursor;
   return cursor !== undefined && cursor !== null && cursor !== "";
 }
+
+function renderError(err: FetchError, level = 0): string {
+  const chainedMessages =
+    err.error_chain
+      ?.map(
+        (chainedError) =>
+          `\n${"  ".repeat(level)}- ${renderError(chainedError, level + 1)}`
+      )
+      .join("\n") ?? "";
+  return (
+    (err.code ? `${err.message} [code: ${err.code}]` : err.message) +
+    chainedMessages
+  );
+}